QEverCloud  6.1.0
Unofficial Evernote Cloud API for Qt
Public Member Functions | Protected Member Functions | List of all members
qevercloud::INoteStore Class Referenceabstract

#include <Services.h>

Inheritance diagram for qevercloud::INoteStore:

Public Member Functions

virtual QString noteStoreUrl () const =0
 
virtual void setNoteStoreUrl (QString url)=0
 
virtual SyncState getSyncState (IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetSyncStateAsync (IRequestContextPtr ctx={})=0
 
virtual SyncChunk getFilteredSyncChunk (qint32 afterUSN, qint32 maxEntries, const SyncChunkFilter &filter, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetFilteredSyncChunkAsync (qint32 afterUSN, qint32 maxEntries, const SyncChunkFilter &filter, IRequestContextPtr ctx={})=0
 
virtual SyncState getLinkedNotebookSyncState (const LinkedNotebook &linkedNotebook, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetLinkedNotebookSyncStateAsync (const LinkedNotebook &linkedNotebook, IRequestContextPtr ctx={})=0
 
virtual SyncChunk getLinkedNotebookSyncChunk (const LinkedNotebook &linkedNotebook, qint32 afterUSN, qint32 maxEntries, bool fullSyncOnly, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetLinkedNotebookSyncChunkAsync (const LinkedNotebook &linkedNotebook, qint32 afterUSN, qint32 maxEntries, bool fullSyncOnly, IRequestContextPtr ctx={})=0
 
virtual QList< NotebooklistNotebooks (IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistNotebooksAsync (IRequestContextPtr ctx={})=0
 
virtual QList< NotebooklistAccessibleBusinessNotebooks (IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistAccessibleBusinessNotebooksAsync (IRequestContextPtr ctx={})=0
 
virtual Notebook getNotebook (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNotebookAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual Notebook getDefaultNotebook (IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetDefaultNotebookAsync (IRequestContextPtr ctx={})=0
 
virtual Notebook createNotebook (const Notebook &notebook, IRequestContextPtr ctx={})=0
 
virtual AsyncResultcreateNotebookAsync (const Notebook &notebook, IRequestContextPtr ctx={})=0
 
virtual qint32 updateNotebook (const Notebook &notebook, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateNotebookAsync (const Notebook &notebook, IRequestContextPtr ctx={})=0
 
virtual qint32 expungeNotebook (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultexpungeNotebookAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual QList< TaglistTags (IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistTagsAsync (IRequestContextPtr ctx={})=0
 
virtual QList< TaglistTagsByNotebook (Guid notebookGuid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistTagsByNotebookAsync (Guid notebookGuid, IRequestContextPtr ctx={})=0
 
virtual Tag getTag (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetTagAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual Tag createTag (const Tag &tag, IRequestContextPtr ctx={})=0
 
virtual AsyncResultcreateTagAsync (const Tag &tag, IRequestContextPtr ctx={})=0
 
virtual qint32 updateTag (const Tag &tag, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateTagAsync (const Tag &tag, IRequestContextPtr ctx={})=0
 
virtual void untagAll (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultuntagAllAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual qint32 expungeTag (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultexpungeTagAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual QList< SavedSearchlistSearches (IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistSearchesAsync (IRequestContextPtr ctx={})=0
 
virtual SavedSearch getSearch (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetSearchAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual SavedSearch createSearch (const SavedSearch &search, IRequestContextPtr ctx={})=0
 
virtual AsyncResultcreateSearchAsync (const SavedSearch &search, IRequestContextPtr ctx={})=0
 
virtual qint32 updateSearch (const SavedSearch &search, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateSearchAsync (const SavedSearch &search, IRequestContextPtr ctx={})=0
 
virtual qint32 expungeSearch (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultexpungeSearchAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual qint32 findNoteOffset (const NoteFilter &filter, Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultfindNoteOffsetAsync (const NoteFilter &filter, Guid guid, IRequestContextPtr ctx={})=0
 
virtual NotesMetadataList findNotesMetadata (const NoteFilter &filter, qint32 offset, qint32 maxNotes, const NotesMetadataResultSpec &resultSpec, IRequestContextPtr ctx={})=0
 
virtual AsyncResultfindNotesMetadataAsync (const NoteFilter &filter, qint32 offset, qint32 maxNotes, const NotesMetadataResultSpec &resultSpec, IRequestContextPtr ctx={})=0
 
virtual NoteCollectionCounts findNoteCounts (const NoteFilter &filter, bool withTrash, IRequestContextPtr ctx={})=0
 
virtual AsyncResultfindNoteCountsAsync (const NoteFilter &filter, bool withTrash, IRequestContextPtr ctx={})=0
 
virtual Note getNoteWithResultSpec (Guid guid, const NoteResultSpec &resultSpec, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteWithResultSpecAsync (Guid guid, const NoteResultSpec &resultSpec, IRequestContextPtr ctx={})=0
 
virtual Note getNote (Guid guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteAsync (Guid guid, bool withContent, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData, IRequestContextPtr ctx={})=0
 
virtual LazyMap getNoteApplicationData (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteApplicationDataAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual QString getNoteApplicationDataEntry (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteApplicationDataEntryAsync (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual qint32 setNoteApplicationDataEntry (Guid guid, QString key, QString value, IRequestContextPtr ctx={})=0
 
virtual AsyncResultsetNoteApplicationDataEntryAsync (Guid guid, QString key, QString value, IRequestContextPtr ctx={})=0
 
virtual qint32 unsetNoteApplicationDataEntry (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual AsyncResultunsetNoteApplicationDataEntryAsync (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual QString getNoteContent (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteContentAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual QString getNoteSearchText (Guid guid, bool noteOnly, bool tokenizeForIndexing, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteSearchTextAsync (Guid guid, bool noteOnly, bool tokenizeForIndexing, IRequestContextPtr ctx={})=0
 
virtual QString getResourceSearchText (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceSearchTextAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual QStringList getNoteTagNames (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteTagNamesAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual Note createNote (const Note &note, IRequestContextPtr ctx={})=0
 
virtual AsyncResultcreateNoteAsync (const Note &note, IRequestContextPtr ctx={})=0
 
virtual Note updateNote (const Note &note, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateNoteAsync (const Note &note, IRequestContextPtr ctx={})=0
 
virtual qint32 deleteNote (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultdeleteNoteAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual qint32 expungeNote (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultexpungeNoteAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual Note copyNote (Guid noteGuid, Guid toNotebookGuid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultcopyNoteAsync (Guid noteGuid, Guid toNotebookGuid, IRequestContextPtr ctx={})=0
 
virtual QList< NoteVersionIdlistNoteVersions (Guid noteGuid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistNoteVersionsAsync (Guid noteGuid, IRequestContextPtr ctx={})=0
 
virtual Note getNoteVersion (Guid noteGuid, qint32 updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNoteVersionAsync (Guid noteGuid, qint32 updateSequenceNum, bool withResourcesData, bool withResourcesRecognition, bool withResourcesAlternateData, IRequestContextPtr ctx={})=0
 
virtual Resource getResource (Guid guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceAsync (Guid guid, bool withData, bool withRecognition, bool withAttributes, bool withAlternateData, IRequestContextPtr ctx={})=0
 
virtual LazyMap getResourceApplicationData (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceApplicationDataAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual QString getResourceApplicationDataEntry (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceApplicationDataEntryAsync (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual qint32 setResourceApplicationDataEntry (Guid guid, QString key, QString value, IRequestContextPtr ctx={})=0
 
virtual AsyncResultsetResourceApplicationDataEntryAsync (Guid guid, QString key, QString value, IRequestContextPtr ctx={})=0
 
virtual qint32 unsetResourceApplicationDataEntry (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual AsyncResultunsetResourceApplicationDataEntryAsync (Guid guid, QString key, IRequestContextPtr ctx={})=0
 
virtual qint32 updateResource (const Resource &resource, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateResourceAsync (const Resource &resource, IRequestContextPtr ctx={})=0
 
virtual QByteArray getResourceData (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceDataAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual Resource getResourceByHash (Guid noteGuid, QByteArray contentHash, bool withData, bool withRecognition, bool withAlternateData, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceByHashAsync (Guid noteGuid, QByteArray contentHash, bool withData, bool withRecognition, bool withAlternateData, IRequestContextPtr ctx={})=0
 
virtual QByteArray getResourceRecognition (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceRecognitionAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual QByteArray getResourceAlternateData (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceAlternateDataAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual ResourceAttributes getResourceAttributes (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetResourceAttributesAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual Notebook getPublicNotebook (UserID userId, QString publicUri, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetPublicNotebookAsync (UserID userId, QString publicUri, IRequestContextPtr ctx={})=0
 
virtual SharedNotebook shareNotebook (const SharedNotebook &sharedNotebook, QString message, IRequestContextPtr ctx={})=0
 
virtual AsyncResultshareNotebookAsync (const SharedNotebook &sharedNotebook, QString message, IRequestContextPtr ctx={})=0
 
virtual CreateOrUpdateNotebookSharesResult createOrUpdateNotebookShares (const NotebookShareTemplate &shareTemplate, IRequestContextPtr ctx={})=0
 
virtual AsyncResultcreateOrUpdateNotebookSharesAsync (const NotebookShareTemplate &shareTemplate, IRequestContextPtr ctx={})=0
 
virtual qint32 updateSharedNotebook (const SharedNotebook &sharedNotebook, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateSharedNotebookAsync (const SharedNotebook &sharedNotebook, IRequestContextPtr ctx={})=0
 
virtual Notebook setNotebookRecipientSettings (QString notebookGuid, const NotebookRecipientSettings &recipientSettings, IRequestContextPtr ctx={})=0
 
virtual AsyncResultsetNotebookRecipientSettingsAsync (QString notebookGuid, const NotebookRecipientSettings &recipientSettings, IRequestContextPtr ctx={})=0
 
virtual QList< SharedNotebooklistSharedNotebooks (IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistSharedNotebooksAsync (IRequestContextPtr ctx={})=0
 
virtual LinkedNotebook createLinkedNotebook (const LinkedNotebook &linkedNotebook, IRequestContextPtr ctx={})=0
 
virtual AsyncResultcreateLinkedNotebookAsync (const LinkedNotebook &linkedNotebook, IRequestContextPtr ctx={})=0
 
virtual qint32 updateLinkedNotebook (const LinkedNotebook &linkedNotebook, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateLinkedNotebookAsync (const LinkedNotebook &linkedNotebook, IRequestContextPtr ctx={})=0
 
virtual QList< LinkedNotebooklistLinkedNotebooks (IRequestContextPtr ctx={})=0
 
virtual AsyncResultlistLinkedNotebooksAsync (IRequestContextPtr ctx={})=0
 
virtual qint32 expungeLinkedNotebook (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultexpungeLinkedNotebookAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AuthenticationResult authenticateToSharedNotebook (QString shareKeyOrGlobalId, IRequestContextPtr ctx={})=0
 
virtual AsyncResultauthenticateToSharedNotebookAsync (QString shareKeyOrGlobalId, IRequestContextPtr ctx={})=0
 
virtual SharedNotebook getSharedNotebookByAuth (IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetSharedNotebookByAuthAsync (IRequestContextPtr ctx={})=0
 
virtual void emailNote (const NoteEmailParameters &parameters, IRequestContextPtr ctx={})=0
 
virtual AsyncResultemailNoteAsync (const NoteEmailParameters &parameters, IRequestContextPtr ctx={})=0
 
virtual QString shareNote (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultshareNoteAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual void stopSharingNote (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultstopSharingNoteAsync (Guid guid, IRequestContextPtr ctx={})=0
 
virtual AuthenticationResult authenticateToSharedNote (QString guid, QString noteKey, IRequestContextPtr ctx={})=0
 
virtual AsyncResultauthenticateToSharedNoteAsync (QString guid, QString noteKey, IRequestContextPtr ctx={})=0
 
virtual RelatedResult findRelated (const RelatedQuery &query, const RelatedResultSpec &resultSpec, IRequestContextPtr ctx={})=0
 
virtual AsyncResultfindRelatedAsync (const RelatedQuery &query, const RelatedResultSpec &resultSpec, IRequestContextPtr ctx={})=0
 
virtual UpdateNoteIfUsnMatchesResult updateNoteIfUsnMatches (const Note &note, IRequestContextPtr ctx={})=0
 
virtual AsyncResultupdateNoteIfUsnMatchesAsync (const Note &note, IRequestContextPtr ctx={})=0
 
virtual ManageNotebookSharesResult manageNotebookShares (const ManageNotebookSharesParameters &parameters, IRequestContextPtr ctx={})=0
 
virtual AsyncResultmanageNotebookSharesAsync (const ManageNotebookSharesParameters &parameters, IRequestContextPtr ctx={})=0
 
virtual ShareRelationships getNotebookShares (QString notebookGuid, IRequestContextPtr ctx={})=0
 
virtual AsyncResultgetNotebookSharesAsync (QString notebookGuid, IRequestContextPtr ctx={})=0
 

Protected Member Functions

 INoteStore (QObject *parent)
 

Detailed Description

Service: NoteStore

The NoteStore service is used by EDAM clients to exchange information about the collection of notes in an account. This is primarily used for synchronization, but could also be used by a "thin" client without a full local cache.

Most functions take an "authenticationToken" parameter, which is the value returned by the UserStore which permits access to the account.

Calls which require an authenticationToken may throw an EDAMUserException for the following reasons:

Constructor & Destructor Documentation

◆ INoteStore()

qevercloud::INoteStore::INoteStore ( QObject *  parent)
inlineprotected

Member Function Documentation

◆ authenticateToSharedNote()

virtual AuthenticationResult qevercloud::INoteStore::authenticateToSharedNote ( QString  guid,
QString  noteKey,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the service to produce an authentication token that can be used to access the contents of a single Note which was individually shared from someone's account. This authenticationToken can be used with the various other NoteStore calls to find and retrieve the Note and its directly-referenced children.

Parameters
guidThe GUID identifying this Note on this shard.
noteKeyThe 'noteKey' identifier from the Note that was originally created via a call to shareNote() and then given to a recipient to access.
authenticationTokenAn optional authenticationToken that identifies the user accessing the shared note. This parameter may be required to access some shared notes.
Exceptions
EDAMUserException
  • PERMISSION_DENIED "Note" - the Note with that GUID is either not shared, or the noteKey doesn't match the current key for this note
  • PERMISSION_DENIED "authenticationToken" - an authentication token is required to access this Note, but either no authentication token or a "non-owner" authentication token was provided.
EDAMNotFoundException
  • "guid" - the note with that GUID is not found
EDAMSystemException
  • TAKEN_DOWN "Note" - The specified shared note is taken down (for all requesters).
  • TAKEN_DOWN "Country" - The specified shared note is taken down for the requester because of an IP-based country lookup.

◆ authenticateToSharedNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::authenticateToSharedNoteAsync ( QString  guid,
QString  noteKey,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of authenticateToSharedNote

◆ authenticateToSharedNotebook()

virtual AuthenticationResult qevercloud::INoteStore::authenticateToSharedNotebook ( QString  shareKeyOrGlobalId,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the service to produce an authentication token that can be used to access the contents of a shared notebook from someone else's account. This authenticationToken can be used with the various other NoteStore calls to find and retrieve notes, and if the permissions in the shared notebook are sufficient, to make changes to the contents of the notebook.

Parameters
shareKeyOrGlobalIdMay be one of the following:
  • A share key for a shared notebook that was granted to some recipient Must be used if you are joining a notebook unless it was shared via createOrUpdateNotebookShares. Share keys are delivered out-of-band and are generally not available to clients. For security reasons, share keys may be invalidated at the discretion of the service.
  • The shared notebook global identifier. May be used to access a notebook that is already joined.
  • The Notebook GUID. May be used to access a notebook that was already joined, or to access a notebook that was shared with the recipient via createOrUpdateNotebookShares.
authenticationTokenIf a non-empty string is provided, this is the full user-based authentication token that identifies the user who is currently logged in and trying to access the shared notebook. If this string is empty, the service will attempt to authenticate to the shared notebook without any logged in user.
Exceptions
EDAMSystemException
  • BAD_DATA_FORMAT "shareKey" - invalid shareKey string
  • INVALID_AUTH "shareKey" - bad signature on shareKey string
EDAMNotFoundException
  • "SharedNotebook.id" - the shared notebook no longer exists
EDAMUserException
  • DATA_REQUIRED "authenticationToken" - the share requires login, and no valid authentication token was provided.
  • PERMISSION_DENIED "SharedNotebook.username" - share requires login, and another username has already been bound to this notebook.

◆ authenticateToSharedNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::authenticateToSharedNotebookAsync ( QString  shareKeyOrGlobalId,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of authenticateToSharedNotebook

◆ copyNote()

virtual Note qevercloud::INoteStore::copyNote ( Guid  noteGuid,
Guid  toNotebookGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Performs a deep copy of the Note with the provided GUID 'noteGuid' into the Notebook with the provided GUID 'toNotebookGuid'. The caller must be the owner of both the Note and the Notebook. This creates a new Note in the destination Notebook with new content and Resources that match all of the content and Resources from the original Note, but with new GUID identifiers. The original Note is not modified by this operation. The copied note is considered as an "upload" for the purpose of upload transfer limit calculation, so its size is added to the upload count for the owner.

If the original note has been shared and has SharedNote records, the shares are NOT copied.

Parameters
noteGuidThe GUID of the Note to copy.
toNotebookGuidThe GUID of the Notebook that should receive the new Note.
Returns
The metadata for the new Note that was created. This will include the new GUID for this Note (and any copied Resources), but will not include the content body or the binary bodies of any Resources.
Exceptions
EDAMUserException
  • LIMIT_REACHED "Note" - at max number per account
  • PERMISSION_DENIED "Notebook.guid" - destination not owned by user
  • PERMISSION_DENIED "Note" - user doesn't own
  • QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
EDAMNotFoundException
  • "Notebook.guid" - not found, by GUID

◆ copyNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::copyNoteAsync ( Guid  noteGuid,
Guid  toNotebookGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of copyNote

◆ createLinkedNotebook()

virtual LinkedNotebook qevercloud::INoteStore::createLinkedNotebook ( const LinkedNotebook linkedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the service to make a linked notebook with the provided name, username of the owner and identifiers provided. A linked notebook can be either a link to a public notebook or to a private shared notebook.

Parameters
linkedNotebookThe desired fields for the linked notebook must be provided on this object. The name of the linked notebook must be set. Either a username uri or a shard id and share key must be provided otherwise a EDAMUserException is thrown.
Returns
The newly created LinkedNotebook. The server-side id will be saved in this object's 'id' field.
Exceptions
EDAMUserException
  • DATA_REQUIRED "LinkedNotebook.shareName" - missing shareName
  • BAD_DATA_FORMAT "LinkedNotebook.name" - invalid shareName length or pattern
  • BAD_DATA_FORMAT "LinkedNotebook.username" - bad username format
  • BAD_DATA_FORMAT "LinkedNotebook.uri" - if public notebook set but bad uri
  • DATA_REQUIRED "LinkedNotebook.shardId" - if private notebook but shard id not provided
  • BAD_DATA_FORMAT "LinkedNotebook.stack" - invalid stack name length or pattern
EDAMSystemException
  • BAD_DATA_FORMAT "LinkedNotebook.sharedNotebookGlobalId" - if a bad global identifer was set on a private notebook

◆ createLinkedNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::createLinkedNotebookAsync ( const LinkedNotebook linkedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of createLinkedNotebook

◆ createNote()

virtual Note qevercloud::INoteStore::createNote ( const Note note,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the service to make a note with the provided set of information.

Parameters
noteA Note object containing the desired fields to be populated on the service.
Returns
The newly created Note from the service. The server-side GUIDs for the Note and any Resources will be saved in this object. The service will include the meta-data for each resource in the note, but the binary contents of the resources and their recognition data will be omitted (except Recognition Resource body, for which the behavior is unspecified).
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.title" - invalid length or pattern
  • BAD_DATA_FORMAT "Note.content" - invalid length for ENML content
  • BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
  • BAD_DATA_FORMAT "NoteAttributes.*" - bad resource string
  • BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
  • DATA_CONFLICT "Note.deleted" - deleted time set on active note
  • DATA_REQUIRED "Resource.data" - resource data body missing
  • ENML_VALIDATION "*" - note content doesn't validate against DTD
  • LIMIT_REACHED "Note" - at max number per account
  • LIMIT_REACHED "Note.size" - total note size too large
  • LIMIT_REACHED "Note.resources" - too many resources on Note
  • LIMIT_REACHED "Note.tagGuids" - too many Tags on Note
  • LIMIT_REACHED "Resource.data.size" - resource too large
  • LIMIT_REACHED "NoteAttribute.*" - attribute string too long
  • LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
  • PERMISSION_DENIED "Note.notebookGuid" - NB not owned by user
  • QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
  • BAD_DATA_FORMAT "Tag.name" - Note.tagNames was provided, and one of the specified tags had an invalid length or pattern
  • LIMIT_REACHED "Tag" - Note.tagNames was provided, and the required new tags would exceed the maximum number per account
EDAMNotFoundException
  • "Note.notebookGuid" - not found, by GUID

◆ createNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::createNoteAsync ( const Note note,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of createNote

◆ createNotebook()

virtual Notebook qevercloud::INoteStore::createNotebook ( const Notebook notebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the service to make a notebook with the provided name.

Parameters
notebookThe desired fields for the notebook must be provided on this object. The name of the notebook must be set, and either the 'active' or 'defaultNotebook' fields may be set by the client at creation. If a notebook exists in the account with the same name (via case-insensitive compare), this will throw an EDAMUserException.
Returns
The newly created Notebook. The server-side GUID will be saved in this object's 'guid' field.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Notebook.name" - invalid length or pattern
  • BAD_DATA_FORMAT "Notebook.stack" - invalid length or pattern
  • BAD_DATA_FORMAT "Publishing.uri" - if publishing set but bad uri
  • BAD_DATA_FORMAT "Publishing.publicDescription" - if too long
  • DATA_CONFLICT "Notebook.name" - name already in use
  • DATA_CONFLICT "Publishing.uri" - if URI already in use
  • DATA_REQUIRED "Publishing.uri" - if publishing set but uri missing
  • DATA_REQUIRED "Notebook" - notebook parameter was null
  • PERMISSION_DENIED "Notebook.defaultNotebook" - if the 'defaultNotebook' field is set to 'true' for a Notebook that is not owned by the user identified by the passed authenticationToken.
  • LIMIT_REACHED "Notebook" - at max number of notebooks
EDAMNotFoundException
  • "Workspace.guid" - if workspaceGuid set and no Workspace exists for the GUID

◆ createNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::createNotebookAsync ( const Notebook notebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of createNotebook

◆ createOrUpdateNotebookShares()

virtual CreateOrUpdateNotebookSharesResult qevercloud::INoteStore::createOrUpdateNotebookShares ( const NotebookShareTemplate shareTemplate,
IRequestContextPtr  ctx = {} 
)
pure virtual

Share a notebook by a messaging thread ID or a list of contacts. This function is intended to be used in conjunction with Evernote messaging, and as such does not notify the recipient that a notebook has been shared with them.

Sharing with a subset of participants on a thread is accomplished by specifying both a thread ID and a list of contacts. This ensures that even if those contacts are on the thread under a deactivated identity, the correct user (the one who has the given contact on the thread) receives the share.

Parameters
authenticationTokenAn authentication token that grants the caller permission to share the notebook. This should be an owner token if the notebook is owned by the caller. If the notebook is a business notebook to which the caller has full access, this should be their business authentication token. If the notebook is a shared (non-business) notebook to which the caller has full access, this should be the shared notebook authentication token returned by NoteStore.authenticateToNotebook.
shareTemplateSpecifies the GUID of the notebook to be shared, the privilege at which the notebook should be shared, and the recipient information.
Returns
A structure containing the USN of the Notebook after the change and a list of created or updated SharedNotebooks.
Exceptions
EDAMUserException
  • DATA_REQUIRED "Notebook.guid" - if no notebook GUID was specified
  • BAD_DATA_FORMAT "Notebook.guid" - if shareTemplate.notebookGuid is not a valid GUID
  • DATA_REQUIRED "shareTemplate" - if the shareTemplate parameter was missing
  • DATA_REQUIRED "NotebookShareTemplate.privilege" - if no privilege was specified
  • DATA_CONFLICT "NotebookShareTemplate.privilege" - if the specified privilege is not allowed.
  • DATA_REQUIRED "NotebookShareTemplate.recipients" - if no recipients were specified, either by thread ID or as a list of contacts
  • LIMIT_REACHED "SharedNotebook" - if the notebook has reached its maximum number of shares
EDAMInvalidContactsException
  • "NotebookShareTemplate.recipients" - if one or more of the recipients specified in shareTemplate.recipients was not syntactically valid, or if attempting to share a notebook with an Evernote identity that the sharer does not have a connection to. The exception will specify which recipients were invalid.
EDAMNotFoundException
  • "Notebook.guid" - if no notebook with the specified GUID was found
  • "NotebookShareTemplate.recipientThreadId" - if the recipient thread ID was specified, but no thread with that ID exists

◆ createOrUpdateNotebookSharesAsync()

virtual AsyncResult* qevercloud::INoteStore::createOrUpdateNotebookSharesAsync ( const NotebookShareTemplate shareTemplate,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of createOrUpdateNotebookShares

◆ createSearch()

virtual SavedSearch qevercloud::INoteStore::createSearch ( const SavedSearch search,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the service to make a saved search with a set of information.

Parameters
searchThe desired list of fields for the search are specified in this object. The caller must specify the name and query for the search, and may optionally specify a search scope. The SavedSearch.format field is ignored by the service.
Returns
The newly created SavedSearch. The server-side GUID will be saved in this object.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "SavedSearch.name" - invalid length or pattern
  • BAD_DATA_FORMAT "SavedSearch.query" - invalid length
  • DATA_CONFLICT "SavedSearch.name" - name already in use
  • LIMIT_REACHED "SavedSearch" - at max number of searches

◆ createSearchAsync()

virtual AsyncResult* qevercloud::INoteStore::createSearchAsync ( const SavedSearch search,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of createSearch

◆ createTag()

virtual Tag qevercloud::INoteStore::createTag ( const Tag tag,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the service to make a tag with a set of information.

Parameters
tagThe desired list of fields for the tag are specified in this object. The caller must specify the tag name, and may provide the parentGUID.
Returns
The newly created Tag. The server-side GUID will be saved in this object.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Tag.name" - invalid length or pattern
  • BAD_DATA_FORMAT "Tag.parentGuid" - malformed GUID
  • DATA_CONFLICT "Tag.name" - name already in use
  • LIMIT_REACHED "Tag" - at max number of tags
EDAMNotFoundException
  • "Tag.parentGuid" - not found, by GUID

◆ createTagAsync()

virtual AsyncResult* qevercloud::INoteStore::createTagAsync ( const Tag tag,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of createTag

◆ deleteNote()

virtual qint32 qevercloud::INoteStore::deleteNote ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Moves the note into the trash. The note may still be undeleted, unless it is expunged. This is equivalent to calling updateNote() after setting Note.active = false

Parameters
guidThe GUID of the note to delete.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • PERMISSION_DENIED "Note" - user doesn't have permission to update the note.
EDAMUserException
  • DATA_CONFLICT "Note.guid" - the note is already deleted
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ deleteNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::deleteNoteAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of deleteNote

◆ emailNote()

virtual void qevercloud::INoteStore::emailNote ( const NoteEmailParameters parameters,
IRequestContextPtr  ctx = {} 
)
pure virtual

Attempts to send a single note to one or more email recipients.

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

Parameters
authenticationTokenThe note will be sent as the user logged in via this token, using that user's registered email address. If the authenticated user doesn't have permission to read that note, the emailing will fail.
parametersThe note must be specified either by GUID (in which case it will be sent using the existing data in the service), or else the full Note must be passed to this call. This also specifies the additional email fields that will be used in the email.
Exceptions
EDAMUserException
  • LIMIT_REACHED "NoteEmailParameters.toAddresses" - The email can't be sent because this would exceed the user's daily email limit.
  • BAD_DATA_FORMAT "(email address)" - email address malformed
  • DATA_REQUIRED "NoteEmailParameters.toAddresses" - if there are no To: or Cc: addresses provided.
  • DATA_REQUIRED "Note.title" - if the caller provides a Note parameter with no title
  • DATA_REQUIRED "Note.content" - if the caller provides a Note parameter with no content
  • ENML_VALIDATION "*" - note content doesn't validate against DTD
  • DATA_REQUIRED "NoteEmailParameters.note" - if no guid or note provided
  • PERMISSION_DENIED "Note" - private note, user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ emailNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::emailNoteAsync ( const NoteEmailParameters parameters,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of emailNote

◆ expungeLinkedNotebook()

virtual qint32 qevercloud::INoteStore::expungeLinkedNotebook ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Permanently expunges the linked notebook from the account.

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

Parameters
guidThe LinkedNotebook.guid field of the LinkedNotebook to permanently remove from the account.

◆ expungeLinkedNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::expungeLinkedNotebookAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of expungeLinkedNotebook

◆ expungeNote()

virtual qint32 qevercloud::INoteStore::expungeNote ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Permanently removes a Note, and all of its Resources, from the service.

NOTE: This function is not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

Parameters
guidThe GUID of the note to delete.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • PERMISSION_DENIED "Note" - user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ expungeNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::expungeNoteAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of expungeNote

◆ expungeNotebook()

virtual qint32 qevercloud::INoteStore::expungeNotebook ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Permanently removes the notebook from the user's account. After this action, the notebook is no longer available for undeletion, etc. If the notebook contains any Notes, they will be moved to the current default notebook and moved into the trash (i.e. Note.active=false).

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

Parameters
guidThe GUID of the notebook to delete.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Notebook.guid" - if the parameter is missing
  • LIMIT_REACHED "Notebook" - trying to expunge the last Notebook
  • PERMISSION_DENIED "Notebook" - private notebook, user doesn't own

◆ expungeNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::expungeNotebookAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of expungeNotebook

◆ expungeSearch()

virtual qint32 qevercloud::INoteStore::expungeSearch ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Permanently deletes the saved search with the provided GUID, if present.

NOTE: This function is generally not available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

Parameters
guidThe GUID of the search to delete.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "SavedSearch.guid" - if the guid parameter is empty
  • PERMISSION_DENIED "SavedSearch" - user doesn't own
EDAMNotFoundException
  • "SavedSearch.guid" - not found, by GUID

◆ expungeSearchAsync()

virtual AsyncResult* qevercloud::INoteStore::expungeSearchAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of expungeSearch

◆ expungeTag()

virtual qint32 qevercloud::INoteStore::expungeTag ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Permanently deletes the tag with the provided GUID, if present.

NOTE: This function is not generally available to third party applications. Calls will result in an EDAMUserException with the error code PERMISSION_DENIED.

Parameters
guidThe GUID of the tag to delete.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Tag.guid" - if the guid parameter is missing
  • PERMISSION_DENIED "Tag" - user doesn't own tag
EDAMNotFoundException
  • "Tag.guid" - tag not found, by GUID

◆ expungeTagAsync()

virtual AsyncResult* qevercloud::INoteStore::expungeTagAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of expungeTag

◆ findNoteCounts()

virtual NoteCollectionCounts qevercloud::INoteStore::findNoteCounts ( const NoteFilter filter,
bool  withTrash,
IRequestContextPtr  ctx = {} 
)
pure virtual

This function is used to determine how many notes are found for each notebook and tag in the user's account, given a current set of filter parameters that determine the current selection. This function will return a structure that gives the note count for each notebook and tag that has at least one note under the requested filter. Any notebook or tag that has zero notes in the filtered set will not be listed in the reply to this function (so they can be assumed to be 0).

Parameters
authenticationTokenMust be a valid token for the user's account unless the NoteFilter 'notebookGuid' is the GUID of a public notebook.
filterThe note selection filter that is currently being applied. The note counts are to be calculated with this filter applied to the total set of notes in the user's account.
withTrashIf true, then the NoteCollectionCounts.trashCount will be calculated and supplied in the reply. Otherwise, the trash value will be omitted.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
  • BAD_DATA_FORMAT "NoteFilter.notebookGuids" - if any are malformed
  • BAD_DATA_FORMAT "NoteFilter.words" - if search string too long

EDAMNotFoundException
  • "Notebook.guid" - not found, by GUID

◆ findNoteCountsAsync()

virtual AsyncResult* qevercloud::INoteStore::findNoteCountsAsync ( const NoteFilter filter,
bool  withTrash,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of findNoteCounts

◆ findNoteOffset()

virtual qint32 qevercloud::INoteStore::findNoteOffset ( const NoteFilter filter,
Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Finds the position of a note within a sorted subset of all of the user's notes. This may be useful for thin clients that are displaying a paginated listing of a large account, which need to know where a particular note sits in the list without retrieving all notes first.

Parameters
authenticationTokenMust be a valid token for the user's account unless the NoteFilter 'notebookGuid' is the GUID of a public notebook.
filterThe list of criteria that will constrain the notes to be returned.
guidThe GUID of the note to be retrieved.
Returns
If the note with the provided GUID is found within the matching note list, this will return the offset of that note within that list (where the first offset is 0). If the note is not found within the set of notes, this will return -1.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "offset" - not between 0 and EDAM_USER_NOTES_MAX
  • BAD_DATA_FORMAT "maxNotes" - not between 0 and EDAM_USER_NOTES_MAX
  • BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
  • BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
  • BAD_DATA_FORMAT "NoteFilter.words" - if search string too long

EDAMNotFoundException
  • "Notebook.guid" - not found, by GUID
  • "Note.guid" - not found, by GUID

◆ findNoteOffsetAsync()

virtual AsyncResult* qevercloud::INoteStore::findNoteOffsetAsync ( const NoteFilter filter,
Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of findNoteOffset

◆ findNotesMetadata()

virtual NotesMetadataList qevercloud::INoteStore::findNotesMetadata ( const NoteFilter filter,
qint32  offset,
qint32  maxNotes,
const NotesMetadataResultSpec resultSpec,
IRequestContextPtr  ctx = {} 
)
pure virtual

Used to find the high-level information about a set of the notes from a user's account based on various criteria specified via a NoteFilter object.

Web applications that wish to periodically check for new content in a user's Evernote account should consider using webhooks instead of polling this API. See http://dev.evernote.com/documentation/cloud/chapters/polling_notification.php for more information.

Parameters
authenticationTokenMust be a valid token for the user's account unless the NoteFilter 'notebookGuid' is the GUID of a public notebook.
filterThe list of criteria that will constrain the notes to be returned.
offsetThe numeric index of the first note to show within the sorted results. The numbering scheme starts with "0". This can be used for pagination.
maxNotesThe maximum notes to return in this query. The service will return a set of notes that is no larger than this number, but may return fewer notes if needed. The NoteList.totalNotes field in the return value will indicate whether there are more values available after the returned set. Currently, the service will not return more than 250 notes in a single request, but this number may change in the future.
resultSpecThis specifies which information should be returned for each matching Note. The fields on this structure can be used to eliminate data that the client doesn't need, which will reduce the time and bandwidth to receive and process the reply.
Returns
The list of notes that match the criteria. The Notes.sharedNotes field will not be set.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "offset" - not between 0 and EDAM_USER_NOTES_MAX
  • BAD_DATA_FORMAT "maxNotes" - not between 0 and EDAM_USER_NOTES_MAX
  • BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
  • BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
  • BAD_DATA_FORMAT "NoteFilter.words" - if search string too long
EDAMNotFoundException
  • "Notebook.guid" - not found, by GUID

◆ findNotesMetadataAsync()

virtual AsyncResult* qevercloud::INoteStore::findNotesMetadataAsync ( const NoteFilter filter,
qint32  offset,
qint32  maxNotes,
const NotesMetadataResultSpec resultSpec,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of findNotesMetadata

◆ findRelated()

virtual RelatedResult qevercloud::INoteStore::findRelated ( const RelatedQuery query,
const RelatedResultSpec resultSpec,
IRequestContextPtr  ctx = {} 
)
pure virtual

Identify related entities on the service, such as notes, notebooks, tags and users in a business related to notes or content.

Parameters
queryThe information about which we are finding related entities.
resultSpecAllows the client to indicate the type and quantity of information to be returned, allowing a saving of time and bandwidth.
Returns
The result of the query, with information considered to likely be relevantly related to the information described by the query.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "RelatedQuery.plainText" - If you provided a a zero-length plain text value.
  • BAD_DATA_FORMAT "RelatedQuery.noteGuid" - If you provided an invalid Note GUID, that is, one that does not match the constraints defined by EDAM_GUID_LEN_MIN, EDAM_GUID_LEN_MAX, EDAM_GUID_REGEX.
  • BAD_DATA_FORMAT "NoteFilter.notebookGuid" - if malformed
  • BAD_DATA_FORMAT "NoteFilter.tagGuids" - if any are malformed
  • BAD_DATA_FORMAT "NoteFilter.words" - if search string too long
  • PERMISSION_DENIED "Note" - If the caller does not have access to the note identified by RelatedQuery.noteGuid.
  • PERMISSION_DENIED "authenticationToken" - If the caller has requested to findExperts in the context of a non business user (i.e. The authenticationToken is not a business auth token).
  • DATA_REQUIRED "RelatedResultSpec" - If you did not not set any values in the result spec.
EDAMNotFoundException
  • "RelatedQuery.noteGuid" - the note with that GUID is not found, if that field has been set in the query.

◆ findRelatedAsync()

virtual AsyncResult* qevercloud::INoteStore::findRelatedAsync ( const RelatedQuery query,
const RelatedResultSpec resultSpec,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of findRelated

◆ getDefaultNotebook()

virtual Notebook qevercloud::INoteStore::getDefaultNotebook ( IRequestContextPtr  ctx = {})
pure virtual

Returns the notebook that should be used to store new notes in the user's account when no other notebooks are specified.

◆ getDefaultNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::getDefaultNotebookAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of getDefaultNotebook

◆ getFilteredSyncChunk()

virtual SyncChunk qevercloud::INoteStore::getFilteredSyncChunk ( qint32  afterUSN,
qint32  maxEntries,
const SyncChunkFilter filter,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the NoteStore to provide the state of the account in order of last modification. This request retrieves one block of the server's state so that a client can make several small requests against a large account rather than getting the entire state in one big message. This call gives fine-grained control of the data that will be received by a client by omitting data elements that a client doesn't need. This may reduce network traffic and sync times.

Parameters
afterUSNThe client can pass this value to ask only for objects that have been updated after a certain point. This allows the client to receive updates after its last checkpoint rather than doing a full synchronization on every pass. The default value of "0" indicates that the client wants to get objects from the start of the account.
maxEntriesThe maximum number of modified objects that should be returned in the result SyncChunk. This can be used to limit the size of each individual message to be friendly for network transfer.
filterThe caller must set some of the flags in this structure to specify which data types should be returned during the synchronization. See the SyncChunkFilter structure for information on each flag.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "afterUSN" - if negative
  • BAD_DATA_FORMAT "maxEntries" - if less than 1

◆ getFilteredSyncChunkAsync()

virtual AsyncResult* qevercloud::INoteStore::getFilteredSyncChunkAsync ( qint32  afterUSN,
qint32  maxEntries,
const SyncChunkFilter filter,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getFilteredSyncChunk

◆ getLinkedNotebookSyncChunk()

virtual SyncChunk qevercloud::INoteStore::getLinkedNotebookSyncChunk ( const LinkedNotebook linkedNotebook,
qint32  afterUSN,
qint32  maxEntries,
bool  fullSyncOnly,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the NoteStore to provide information about the contents of a linked notebook that has been shared with the caller, or that is public to the world. This will return a result that is similar to getSyncChunk, but will only contain entries that are visible to the caller. I.e. only that particular Notebook will be visible, along with its Notes, and Tags on those Notes.

This function must be called on the shard that owns the referenced notebook. (I.e. the shardId in /shard/shardId/edam/note must be the same as LinkedNotebook.shardId.)

Parameters
authenticationTokenThis should be an authenticationToken for the guest who has received the invitation to the share. (I.e. this should not be the result of NoteStore.authenticateToSharedNotebook)
linkedNotebookThis structure should contain identifying information and permissions to access the notebook in question. This must contain the valid fields for either a shared notebook (e.g. shareKey) or a public notebook (e.g. username, uri)
afterUSNThe client can pass this value to ask only for objects that have been updated after a certain point. This allows the client to receive updates after its last checkpoint rather than doing a full synchronization on every pass. The default value of "0" indicates that the client wants to get objects from the start of the account.
maxEntriesThe maximum number of modified objects that should be returned in the result SyncChunk. This can be used to limit the size of each individual message to be friendly for network transfer. Applications should not request more than 256 objects at a time, and must handle the case where the service returns less than the requested number of objects in a given request even though more objects are available on the service.
fullSyncOnlyIf true, then the client only wants initial data for a full sync. In this case, the service will not return any expunged objects, and will not return any Resources, since these are also provided in their corresponding Notes.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "afterUSN" - if negative
  • BAD_DATA_FORMAT "maxEntries" - if less than 1
EDAMNotFoundException
  • "LinkedNotebook" - if the provided information doesn't match any valid notebook
  • "LinkedNotebook.uri" - if the provided public URI doesn't match any valid notebook
  • "SharedNotebook.id" - if the provided information indicates a shared notebook that no longer exists

◆ getLinkedNotebookSyncChunkAsync()

virtual AsyncResult* qevercloud::INoteStore::getLinkedNotebookSyncChunkAsync ( const LinkedNotebook linkedNotebook,
qint32  afterUSN,
qint32  maxEntries,
bool  fullSyncOnly,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getLinkedNotebookSyncChunk

◆ getLinkedNotebookSyncState()

virtual SyncState qevercloud::INoteStore::getLinkedNotebookSyncState ( const LinkedNotebook linkedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asks the NoteStore to provide information about the status of a linked notebook that has been shared with the caller, or that is public to the world. This will return a result that is similar to getSyncState, but may omit SyncState.uploaded if the caller doesn't have permission to write to the linked notebook.

This function must be called on the shard that owns the referenced notebook. (I.e. the shardId in /shard/shardId/edam/note must be the same as LinkedNotebook.shardId.)

Parameters
authenticationTokenThis should be an authenticationToken for the guest who has received the invitation to the share. (I.e. this should not be the result of NoteStore.authenticateToSharedNotebook)
linkedNotebookThis structure should contain identifying information and permissions to access the notebook in question.
Exceptions
EDAMUserException
  • DATA_REQUIRED "LinkedNotebook.username" - The username field must be populated with the current username of the owner of the notebook for which you are obtaining sync state.
EDAMNotFoundException
  • "LinkedNotebook.username" - If the LinkedNotebook.username field does not correspond to a current user on the service.
SystemException
  • SHARD_UNAVAILABLE - If the provided LinkedNotebook.username corresponds to a user whose account is on a shard other than that on which this method was invoked.

◆ getLinkedNotebookSyncStateAsync()

virtual AsyncResult* qevercloud::INoteStore::getLinkedNotebookSyncStateAsync ( const LinkedNotebook linkedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getLinkedNotebookSyncState

◆ getNote()

virtual Note qevercloud::INoteStore::getNote ( Guid  guid,
bool  withContent,
bool  withResourcesData,
bool  withResourcesRecognition,
bool  withResourcesAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

DEPRECATED. See getNoteWithResultSpec.

This function is equivalent to getNoteWithResultSpec, with each of the boolean parameters mapping to the equivalent field of a NoteResultSpec. The Note.sharedNotes field is never populated on the returned note. To get a note with its shares, use getNoteWithResultSpec.

◆ getNoteApplicationData()

virtual LazyMap qevercloud::INoteStore::getNoteApplicationData ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Get all of the application data for the note identified by GUID, with values returned within the LazyMap fullMap field. If there are no applicationData entries, then a LazyMap with an empty fullMap will be returned. If your application only needs to fetch its own applicationData entry, use getNoteApplicationDataEntry instead.

◆ getNoteApplicationDataAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteApplicationDataAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNoteApplicationData

◆ getNoteApplicationDataEntry()

virtual QString qevercloud::INoteStore::getNoteApplicationDataEntry ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Get the value of a single entry in the applicationData map for the note identified by GUID.

Exceptions
EDAMNotFoundException
  • "Note.guid" - note not found, by GUID
  • "NoteAttributes.applicationData.key" - note not found, by key

◆ getNoteApplicationDataEntryAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteApplicationDataEntryAsync ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNoteApplicationDataEntry

◆ getNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteAsync ( Guid  guid,
bool  withContent,
bool  withResourcesData,
bool  withResourcesRecognition,
bool  withResourcesAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNote

◆ getNotebook()

virtual Notebook qevercloud::INoteStore::getNotebook ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the current state of the notebook with the provided GUID. The notebook may be active or deleted (but not expunged).

Parameters
guidThe GUID of the notebook to be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Notebook.guid" - if the parameter is missing
  • PERMISSION_DENIED "Notebook" - private notebook, user doesn't own
EDAMNotFoundException
  • "Notebook.guid" - tag not found, by GUID

◆ getNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::getNotebookAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNotebook

◆ getNotebookShares()

virtual ShareRelationships qevercloud::INoteStore::getNotebookShares ( QString  notebookGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Return the share relationships for the given notebook, including both the invitations and the memberships.

Note: Beta method! This method is currently intended for limited use by Evernote clients that have discussed using this routine with the platform team.

◆ getNotebookSharesAsync()

virtual AsyncResult* qevercloud::INoteStore::getNotebookSharesAsync ( QString  notebookGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNotebookShares

◆ getNoteContent()

virtual QString qevercloud::INoteStore::getNoteContent ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns XHTML contents of the note with the provided GUID. If the Note is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

Parameters
guidThe GUID of the note to be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
  • PERMISSION_DENIED "Note" - private note, user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ getNoteContentAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteContentAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNoteContent

◆ getNoteSearchText()

virtual QString qevercloud::INoteStore::getNoteSearchText ( Guid  guid,
bool  noteOnly,
bool  tokenizeForIndexing,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns a block of the extracted plain text contents of the note with the provided GUID. This text can be indexed for search purposes by a light client that doesn't have capabilities to extract all of the searchable text content from the note and its resources.

If the Note is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

Parameters
guidThe GUID of the note to be retrieved.
noteOnlyIf true, this will only return the text extracted from the ENML contents of the note itself. If false, this will also include the extracted text from any text-bearing resources (PDF, recognized images)
tokenizeForIndexingIf true, this will break the text into cleanly separated and sanitized tokens. If false, this will return the more raw text extraction, with its original punctuation, capitalization, spacing, etc.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
  • PERMISSION_DENIED "Note" - private note, user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ getNoteSearchTextAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteSearchTextAsync ( Guid  guid,
bool  noteOnly,
bool  tokenizeForIndexing,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNoteSearchText

◆ getNoteTagNames()

virtual QStringList qevercloud::INoteStore::getNoteTagNames ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns a list of the names of the tags for the note with the provided guid. This can be used with authentication to get the tags for a user's own note, or can be used without valid authentication to retrieve the names of the tags for a note in a public notebook.

Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
  • PERMISSION_DENIED "Note" - private note, user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ getNoteTagNamesAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteTagNamesAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNoteTagNames

◆ getNoteVersion()

virtual Note qevercloud::INoteStore::getNoteVersion ( Guid  noteGuid,
qint32  updateSequenceNum,
bool  withResourcesData,
bool  withResourcesRecognition,
bool  withResourcesAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

This can be used to retrieve a previous version of a Note after it has been updated within the service. The caller must identify the note (via its guid) and the version (via the updateSequenceNumber of that version). to find a listing of the stored version USNs for a note, call listNoteVersions. This call is only available for notes in Premium accounts. (I.e. access to past versions of Notes is a Premium-only feature.)

Parameters
noteGuidThe GUID of the note to be retrieved.
updateSequenceNumThe USN of the version of the note that is being retrieved
withResourcesDataIf true, any Resource elements in this Note will include the binary contents of their 'data' field's body.
withResourcesRecognitionIf true, any Resource elements will include the binary contents of the 'recognition' field's body if recognition data is present.
withResourcesAlternateDataIf true, any Resource elements in this Note will include the binary contents of their 'alternateData' fields' body, if an alternate form is present.
Exceptions
EDAMUserException
  • DATA_REQUIRED "Note.guid" - if GUID is null or empty string.
  • BAD_DATA_FORMAT "Note.guid" - if GUID is not of correct length.
EDAMNotFoundException
  • "Note.guid" - not found, by GUID.
  • "Note.updateSequenceNumber" - the Note doesn't have a version with the corresponding USN.

◆ getNoteVersionAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteVersionAsync ( Guid  noteGuid,
qint32  updateSequenceNum,
bool  withResourcesData,
bool  withResourcesRecognition,
bool  withResourcesAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNoteVersion

◆ getNoteWithResultSpec()

virtual Note qevercloud::INoteStore::getNoteWithResultSpec ( Guid  guid,
const NoteResultSpec resultSpec,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the current state of the note in the service with the provided GUID. The ENML contents of the note will only be provided if the 'withContent' parameter is true. The service will include the meta-data for each resource in the note, but the binary content depends on whether it is explicitly requested in resultSpec parameter. If the Note is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string). The applicationData fields are returned as keysOnly.

Parameters
authenticationTokenAn authentication token that grants the caller access to the requested note.
guidThe GUID of the note to be retrieved.
resultSpecA structure specifying the fields of the note that the caller would like to get.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
  • PERMISSION_DENIED "Note" - private note, user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ getNoteWithResultSpecAsync()

virtual AsyncResult* qevercloud::INoteStore::getNoteWithResultSpecAsync ( Guid  guid,
const NoteResultSpec resultSpec,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getNoteWithResultSpec

◆ getPublicNotebook()

virtual Notebook qevercloud::INoteStore::getPublicNotebook ( UserID  userId,
QString  publicUri,
IRequestContextPtr  ctx = {} 
)
pure virtual

Looks for a user account with the provided userId on this NoteStore shard and determines whether that account contains a public notebook with the given URI. If the account is not found, or no public notebook exists with this URI, this will throw an EDAMNotFoundException, otherwise this will return the information for that Notebook.

If a notebook is visible on the web with a full URL like http://www.evernote.com/pub/sethdemo/api Then 'sethdemo' is the username that can be used to look up the userId, and 'api' is the publicUri.

Parameters
userIdThe numeric identifier for the user who owns the public notebook. To find this value based on a username string, you can invoke UserStore.getPublicUserInfo
publicUriThe uri string for the public notebook, from Notebook.publishing.uri.
Exceptions
EDAMNotFoundException
  • "Publishing.uri" - not found, by URI
EDAMSystemException
  • TAKEN_DOWN "PublicNotebook" - The specified public notebook is taken down (for all requesters).
  • TAKEN_DOWN "Country" - The specified public notebook is taken down for the requester because of an IP-based country lookup.

◆ getPublicNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::getPublicNotebookAsync ( UserID  userId,
QString  publicUri,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getPublicNotebook

◆ getResource()

virtual Resource qevercloud::INoteStore::getResource ( Guid  guid,
bool  withData,
bool  withRecognition,
bool  withAttributes,
bool  withAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the current state of the resource in the service with the provided GUID. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string). Only the keys for the applicationData will be returned.

Parameters
guidThe GUID of the resource to be retrieved.
withDataIf true, the Resource will include the binary contents of the 'data' field's body.
withRecognitionIf true, the Resource will include the binary contents of the 'recognition' field's body if recognition data is present.
withAttributesIf true, the Resource will include the attributes
withAlternateDataIf true, the Resource will include the binary contents of the 'alternateData' field's body, if an alternate form is present.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Resource.guid" - not found, by GUID

◆ getResourceAlternateData()

virtual QByteArray qevercloud::INoteStore::getResourceAlternateData ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

If the Resource with the provided GUID has an alternate data representation (indicated via the Resource.alternateData field), then this request can be used to retrieve the binary contents of that alternate data file. If the caller asks about a resource that has no alternate data form, this will throw EDAMNotFoundException.

Parameters
guidThe GUID of the resource whose recognition data should be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Resource.guid" - not found, by GUID
  • "Resource.alternateData" - resource has no recognition

◆ getResourceAlternateDataAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceAlternateDataAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceAlternateData

◆ getResourceApplicationData()

virtual LazyMap qevercloud::INoteStore::getResourceApplicationData ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Get all of the application data for the Resource identified by GUID, with values returned within the LazyMap fullMap field. If there are no applicationData entries, then a LazyMap with an empty fullMap will be returned. If your application only needs to fetch its own applicationData entry, use getResourceApplicationDataEntry instead.

◆ getResourceApplicationDataAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceApplicationDataAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceApplicationData

◆ getResourceApplicationDataEntry()

virtual QString qevercloud::INoteStore::getResourceApplicationDataEntry ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Get the value of a single entry in the applicationData map for the Resource identified by GUID.

Exceptions
EDAMNotFoundException
  • "Resource.guid" - Resource not found, by GUID
  • "ResourceAttributes.applicationData.key" - Resource not found, by key

◆ getResourceApplicationDataEntryAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceApplicationDataEntryAsync ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceApplicationDataEntry

◆ getResourceAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceAsync ( Guid  guid,
bool  withData,
bool  withRecognition,
bool  withAttributes,
bool  withAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResource

◆ getResourceAttributes()

virtual ResourceAttributes qevercloud::INoteStore::getResourceAttributes ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the set of attributes for the Resource with the provided GUID. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

Parameters
guidThe GUID of the resource whose attributes should be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Resource.guid" - not found, by GUID

◆ getResourceAttributesAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceAttributesAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceAttributes

◆ getResourceByHash()

virtual Resource qevercloud::INoteStore::getResourceByHash ( Guid  noteGuid,
QByteArray  contentHash,
bool  withData,
bool  withRecognition,
bool  withAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the current state of a resource, referenced by containing note GUID and resource content hash.

Parameters
noteGuidThe GUID of the note that holds the resource to be retrieved.
contentHashThe MD5 checksum of the resource within that note. Note that this is the binary checksum, for example from Resource.data.bodyHash, and not the hex-encoded checksum that is used within an en-media tag in a note body.
withDataIf true, the Resource will include the binary contents of the 'data' field's body.
withRecognitionIf true, the Resource will include the binary contents of the 'recognition' field's body.
withAlternateDataIf true, the Resource will include the binary contents of the 'alternateData' field's body, if an alternate form is present.
Exceptions
EDAMUserException
  • DATA_REQUIRED "Note.guid" - noteGuid param missing
  • DATA_REQUIRED "Note.contentHash" - contentHash param missing
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Note" - not found, by guid
  • "Resource" - not found, by hash

◆ getResourceByHashAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceByHashAsync ( Guid  noteGuid,
QByteArray  contentHash,
bool  withData,
bool  withRecognition,
bool  withAlternateData,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceByHash

◆ getResourceData()

virtual QByteArray qevercloud::INoteStore::getResourceData ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns binary data of the resource with the provided GUID. For example, if this were an image resource, this would contain the raw bits of the image. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

Parameters
guidThe GUID of the resource to be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Resource.guid" - not found, by GUID

◆ getResourceDataAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceDataAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceData

◆ getResourceRecognition()

virtual QByteArray qevercloud::INoteStore::getResourceRecognition ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the binary contents of the recognition index for the resource with the provided GUID. If the caller asks about a resource that has no recognition data, this will throw EDAMNotFoundException. If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

Parameters
guidThe GUID of the resource whose recognition data should be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Resource.guid" - not found, by GUID
  • "Resource.recognition" - resource has no recognition

◆ getResourceRecognitionAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceRecognitionAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceRecognition

◆ getResourceSearchText()

virtual QString qevercloud::INoteStore::getResourceSearchText ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns a block of the extracted plain text contents of the resource with the provided GUID. This text can be indexed for search purposes by a light client that doesn't have capability to extract all of the searchable text content from a resource.

If the Resource is found in a public notebook, the authenticationToken will be ignored (so it could be an empty string).

Parameters
guidThe GUID of the resource to be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Resource.guid" - not found, by GUID

◆ getResourceSearchTextAsync()

virtual AsyncResult* qevercloud::INoteStore::getResourceSearchTextAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getResourceSearchText

◆ getSearch()

virtual SavedSearch qevercloud::INoteStore::getSearch ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the current state of the search with the provided GUID.

Parameters
guidThe GUID of the search to be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "SavedSearch.guid" - if the parameter is missing
  • PERMISSION_DENIED "SavedSearch" - private Tag, user doesn't own

EDAMNotFoundException
  • "SavedSearch.guid" - not found, by GUID

◆ getSearchAsync()

virtual AsyncResult* qevercloud::INoteStore::getSearchAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getSearch

◆ getSharedNotebookByAuth()

virtual SharedNotebook qevercloud::INoteStore::getSharedNotebookByAuth ( IRequestContextPtr  ctx = {})
pure virtual

This function is used to retrieve extended information about a shared notebook by a guest who has already authenticated to access that notebook. This requires an 'authenticationToken' parameter which should be the resut of a call to authenticateToSharedNotebook(...). I.e. this is the token that gives access to the particular shared notebook in someone else's account – it's not the authenticationToken for the owner of the notebook itself.

Parameters
authenticationTokenShould be the authentication token retrieved from the reply of authenticateToSharedNotebook(), proving access to a particular shared notebook.
Exceptions
EDAMUserException
  • PERMISSION_DENIED "authenticationToken" - authentication token doesn't correspond to a valid shared notebook
EDAMNotFoundException
  • "SharedNotebook.id" - the shared notebook no longer exists

◆ getSharedNotebookByAuthAsync()

virtual AsyncResult* qevercloud::INoteStore::getSharedNotebookByAuthAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of getSharedNotebookByAuth

◆ getSyncState()

virtual SyncState qevercloud::INoteStore::getSyncState ( IRequestContextPtr  ctx = {})
pure virtual

Asks the NoteStore to provide information about the status of the user account corresponding to the provided authentication token.

◆ getSyncStateAsync()

virtual AsyncResult* qevercloud::INoteStore::getSyncStateAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of getSyncState

◆ getTag()

virtual Tag qevercloud::INoteStore::getTag ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns the current state of the Tag with the provided GUID.

Parameters
guidThe GUID of the tag to be retrieved.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Tag.guid" - if the parameter is missing
  • PERMISSION_DENIED "Tag" - private Tag, user doesn't own
EDAMNotFoundException
  • "Tag.guid" - tag not found, by GUID

◆ getTagAsync()

virtual AsyncResult* qevercloud::INoteStore::getTagAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of getTag

◆ listAccessibleBusinessNotebooks()

virtual QList<Notebook> qevercloud::INoteStore::listAccessibleBusinessNotebooks ( IRequestContextPtr  ctx = {})
pure virtual

Returns a list of all the notebooks in a business that the user has permission to access, regardless of whether the user has joined them. This includes notebooks that have been shared with the entire business as well as notebooks that have been shared directly with the user.

Parameters
authenticationTokenA business authentication token obtained by calling UserStore.authenticateToBusiness.
Exceptions
EDAMUserException
  • INVALID_AUTH "authenticationToken" - if the authentication token is not a business auth token.

◆ listAccessibleBusinessNotebooksAsync()

virtual AsyncResult* qevercloud::INoteStore::listAccessibleBusinessNotebooksAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of listAccessibleBusinessNotebooks

◆ listLinkedNotebooks()

virtual QList<LinkedNotebook> qevercloud::INoteStore::listLinkedNotebooks ( IRequestContextPtr  ctx = {})
pure virtual

Returns a list of linked notebooks

◆ listLinkedNotebooksAsync()

virtual AsyncResult* qevercloud::INoteStore::listLinkedNotebooksAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of listLinkedNotebooks

◆ listNotebooks()

virtual QList<Notebook> qevercloud::INoteStore::listNotebooks ( IRequestContextPtr  ctx = {})
pure virtual

Returns a list of all of the notebooks in the account.

◆ listNotebooksAsync()

virtual AsyncResult* qevercloud::INoteStore::listNotebooksAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of listNotebooks

◆ listNoteVersions()

virtual QList<NoteVersionId> qevercloud::INoteStore::listNoteVersions ( Guid  noteGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns a list of the prior versions of a particular note that are saved within the service. These prior versions are stored to provide a recovery from unintentional removal of content from a note. The identifiers that are returned by this call can be used with getNoteVersion to retrieve the previous note. The identifiers will be listed from the most recent versions to the oldest. This call is only available for notes in Premium accounts. (I.e. access to past versions of Notes is a Premium-only feature.)

Exceptions
EDAMUserException
  • DATA_REQUIRED "Note.guid" - if GUID is null or empty string.
  • BAD_DATA_FORMAT "Note.guid" - if GUID is not of correct length.
EDAMNotFoundException
  • "Note.guid" - not found, by GUID.

◆ listNoteVersionsAsync()

virtual AsyncResult* qevercloud::INoteStore::listNoteVersionsAsync ( Guid  noteGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of listNoteVersions

◆ listSearches()

virtual QList<SavedSearch> qevercloud::INoteStore::listSearches ( IRequestContextPtr  ctx = {})
pure virtual

Returns a list of the searches in the account. Evernote does not support the undeletion of searches, so this will only include active searches.

◆ listSearchesAsync()

virtual AsyncResult* qevercloud::INoteStore::listSearchesAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of listSearches

◆ listSharedNotebooks()

virtual QList<SharedNotebook> qevercloud::INoteStore::listSharedNotebooks ( IRequestContextPtr  ctx = {})
pure virtual

Lists the collection of shared notebooks for all notebooks in the users account.

Returns
The list of all SharedNotebooks for the user

◆ listSharedNotebooksAsync()

virtual AsyncResult* qevercloud::INoteStore::listSharedNotebooksAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of listSharedNotebooks

◆ listTags()

virtual QList<Tag> qevercloud::INoteStore::listTags ( IRequestContextPtr  ctx = {})
pure virtual

Returns a list of the tags in the account. Evernote does not support the undeletion of tags, so this will only include active tags.

◆ listTagsAsync()

virtual AsyncResult* qevercloud::INoteStore::listTagsAsync ( IRequestContextPtr  ctx = {})
pure virtual

Asynchronous version of listTags

◆ listTagsByNotebook()

virtual QList<Tag> qevercloud::INoteStore::listTagsByNotebook ( Guid  notebookGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Returns a list of the tags that are applied to at least one note within the provided notebook. If the notebook is public, the authenticationToken may be ignored.

Parameters
notebookGuidthe GUID of the notebook to use to find tags
Exceptions
EDAMNotFoundException
  • "Notebook.guid" - notebook not found by GUID

◆ listTagsByNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::listTagsByNotebookAsync ( Guid  notebookGuid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of listTagsByNotebook

◆ manageNotebookShares()

virtual ManageNotebookSharesResult qevercloud::INoteStore::manageNotebookShares ( const ManageNotebookSharesParameters parameters,
IRequestContextPtr  ctx = {} 
)
pure virtual

Manage invitations and memberships associated with a given notebook.

Note: Beta method! This method is currently intended for limited use by Evernote clients that have discussed using this routine with the platform team.

Parameters
parametersA structure containing all parameters for the updates. See the structure documentation for details.
Exceptions
EDAMUserException
  • EDAMErrorCode.LIMIT_REACHED "SharedNotebook" - Trying to share a notebook while the notebook already has EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX shares.

◆ manageNotebookSharesAsync()

virtual AsyncResult* qevercloud::INoteStore::manageNotebookSharesAsync ( const ManageNotebookSharesParameters parameters,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of manageNotebookShares

◆ noteStoreUrl()

virtual QString qevercloud::INoteStore::noteStoreUrl ( ) const
pure virtual

◆ setNoteApplicationDataEntry()

virtual qint32 qevercloud::INoteStore::setNoteApplicationDataEntry ( Guid  guid,
QString  key,
QString  value,
IRequestContextPtr  ctx = {} 
)
pure virtual

Update, or create, an entry in the applicationData map for the note identified by guid.

◆ setNoteApplicationDataEntryAsync()

virtual AsyncResult* qevercloud::INoteStore::setNoteApplicationDataEntryAsync ( Guid  guid,
QString  key,
QString  value,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of setNoteApplicationDataEntry

◆ setNotebookRecipientSettings()

virtual Notebook qevercloud::INoteStore::setNotebookRecipientSettings ( QString  notebookGuid,
const NotebookRecipientSettings recipientSettings,
IRequestContextPtr  ctx = {} 
)
pure virtual

Set values for the recipient settings associated with a notebook share. Only the recipient of the share can update their recipient settings.

If you do not wish to, or cannot, change one of the recipient settings fields, you must leave that field unset in recipientSettings. This method will skip that field for updates and attempt to leave the existing value as it is.

If recipientSettings.inMyList is false, both reminderNotifyInApp and reminderNotifyEmail will be either left as null or converted to false (if currently true).

To unset a notebook's stack, pass in the empty string for the stack field.

Parameters
authenticationTokenThe owner authentication token for the recipient of the share.
Returns
The updated Notebook with the new recipient settings. Note that some of the recipient settings may differ from what was requested. Clients should update their state based on this return value.
Exceptions
EDAMNotFoundException
  • Notebook.guid - Thrown if the service does not have a notebook record with the notebookGuid on the given shard.
  • Publishing.publishState - Thrown if the business notebook is not shared with the user and is also not published to their business.
EDAMUserException
  • PEMISSION_DENIED "authenticationToken" - If the owner of the given token is not allowed to set recipient settings on the specified notebook.
  • DATA_CONFLICT "recipientSettings.reminderNotifyEmail" - Setting reminderNotifyEmail is allowed only for notebooks which belong to the same business as the user.
  • DATA_CONFLICT "recipientSettings.inMyList" - If the request is setting inMyList to false and any of reminder* settings to true.

◆ setNotebookRecipientSettingsAsync()

virtual AsyncResult* qevercloud::INoteStore::setNotebookRecipientSettingsAsync ( QString  notebookGuid,
const NotebookRecipientSettings recipientSettings,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of setNotebookRecipientSettings

◆ setNoteStoreUrl()

virtual void qevercloud::INoteStore::setNoteStoreUrl ( QString  url)
pure virtual

◆ setResourceApplicationDataEntry()

virtual qint32 qevercloud::INoteStore::setResourceApplicationDataEntry ( Guid  guid,
QString  key,
QString  value,
IRequestContextPtr  ctx = {} 
)
pure virtual

Update, or create, an entry in the applicationData map for the Resource identified by guid.

◆ setResourceApplicationDataEntryAsync()

virtual AsyncResult* qevercloud::INoteStore::setResourceApplicationDataEntryAsync ( Guid  guid,
QString  key,
QString  value,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of setResourceApplicationDataEntry

◆ shareNote()

virtual QString qevercloud::INoteStore::shareNote ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

If this note is not already shared publicly (via its own direct URL), then this will start sharing that note. This will return the secret "Note Key" for this note that can currently be used in conjunction with the Note's GUID to gain direct read-only access to the Note. If the note is already shared, then this won't make any changes to the note, and the existing "Note Key" will be returned. The only way to change the Note Key for an existing note is to stopSharingNote first, and then call this function.

Parameters
guidThe GUID of the note to be shared.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
  • PERMISSION_DENIED "Note" - private note, user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ shareNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::shareNoteAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of shareNote

◆ shareNotebook()

virtual SharedNotebook qevercloud::INoteStore::shareNotebook ( const SharedNotebook sharedNotebook,
QString  message,
IRequestContextPtr  ctx = {} 
)
pure virtual

@Deprecated for first-party clients. See createOrUpdateNotebookShares.

Share a notebook with an email address, and optionally to a specific recipient. If an existing SharedNotebook associated with sharedNotebook.notebookGuid is found by recipientUsername or email, then the values of sharedNotebook will be used to update the existing record, else a new record will be created.

If recipientUsername is set and there is already a SharedNotebook for that Notebook with that recipientUsername and the privileges on the existing notebook are lower, than on this one, this will update the privileges and sharerUserId. If there isn't an existing SharedNotebook for recipientUsername, this will create and return a shared notebook for that email and recipientUsername. If recipientUsername is not set and there already is a SharedNotebook for a Notebook for that email address and the privileges on the existing SharedNotebook are lower than on this one, this will update the privileges and sharerUserId, and return the updated SharedNotebook. Otherwise, this will create and return a SharedNotebook for the email address.

If the authenticationToken is a Business auth token, recipientUsername is set and the recipient is in the same business as the business auth token, this method will also auto-join the business user to the SharedNotebook - that is it will set serviceJoined on the SharedNotebook and create a LinkedNotebook on the recipient's account pointing to the SharedNotebook. The LinkedNotebook creation happens out-of-band, so there will be a delay on the order of half a minute between the SharedNotebook and LinkedNotebook creation.

Also handles sending an email to the email addresses: if a SharedNotebook is being created, this will send the shared notebook invite email, and if a SharedNotebook already exists, it will send the shared notebook reminder email. Both these emails contain a link to join the notebook. If the notebook is being auto-joined, it sends an email with that information to the recipient.

Parameters
authenticationTokenMust be an authentication token from the owner or a shared notebook authentication token or business authentication token with sufficient permissions to change invitations for a notebook.
sharedNotebookA shared notebook object populated with the email address of the share recipient, the notebook guid and the access permissions. All other attributes of the shared object are ignored. The SharedNotebook.allowPreview field must be explicitly set with either a true or false value.
messageThe sharer-defined message to put in the email sent out.
Returns
The fully populated SharedNotebook object including the server assigned globalId which can both be used to uniquely identify the SharedNotebook.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "SharedNotebook.email" - if the email was not valid
  • DATA_REQUIRED "SharedNotebook.privilege" - if the SharedNotebook.privilegeLevel was not set.
  • BAD_DATA_FORMAT "SharedNotebook.requireLogin" - if requireLogin was set. requireLogin is deprecated.
  • BAD_DATA_FORMAT "SharedNotebook.privilegeLevel" - if the SharedNotebook.privilegeLevel field was unset or set to GROUP.
  • PERMISSION_DENIED "user" - if the email address on the authenticationToken's owner's account is not confirmed.
  • PERMISSION_DENIED "SharedNotebook.recipientSettings" - if recipientSettings is set in the sharedNotebook. Only the recipient can set these values via the setSharedNotebookRecipientSettings method.
  • EDAMErrorCode.LIMIT_REACHED "SharedNotebook" - The notebook already has EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX shares.
EDAMNotFoundException
  • Notebook.guid - if the notebookGuid is not a valid GUID for the user.

◆ shareNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::shareNotebookAsync ( const SharedNotebook sharedNotebook,
QString  message,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of shareNotebook

◆ stopSharingNote()

virtual void qevercloud::INoteStore::stopSharingNote ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

If this note is shared publicly then this will stop sharing that note and invalidate its "Note Key", so any existing URLs to access that Note will stop working.

If the Note is not shared, then this function will do nothing.

This function does not remove individual shares for the note. To remove individual shares, see stopSharingNoteWithRecipients.

Parameters
guidThe GUID of the note to be un-shared.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.guid" - if the parameter is missing
  • PERMISSION_DENIED "Note" - private note, user doesn't own
EDAMNotFoundException
  • "Note.guid" - not found, by GUID

◆ stopSharingNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::stopSharingNoteAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of stopSharingNote

◆ unsetNoteApplicationDataEntry()

virtual qint32 qevercloud::INoteStore::unsetNoteApplicationDataEntry ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Remove an entry identified by 'key' from the applicationData map for the note identified by 'guid'. Silently ignores an unset of a non-existing key.

◆ unsetNoteApplicationDataEntryAsync()

virtual AsyncResult* qevercloud::INoteStore::unsetNoteApplicationDataEntryAsync ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of unsetNoteApplicationDataEntry

◆ unsetResourceApplicationDataEntry()

virtual qint32 qevercloud::INoteStore::unsetResourceApplicationDataEntry ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Remove an entry identified by 'key' from the applicationData map for the Resource identified by 'guid'.

◆ unsetResourceApplicationDataEntryAsync()

virtual AsyncResult* qevercloud::INoteStore::unsetResourceApplicationDataEntryAsync ( Guid  guid,
QString  key,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of unsetResourceApplicationDataEntry

◆ untagAll()

virtual void qevercloud::INoteStore::untagAll ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Removes the provided tag from every note that is currently tagged with this tag. If this operation is successful, the tag will still be in the account, but it will not be tagged on any notes.

This function is not indended for use by full synchronizing clients, since it does not provide enough result information to the client to reconcile the local state without performing a follow-up sync from the service. This is intended for "thin clients" that need to efficiently support this as a UI operation.

Parameters
guidThe GUID of the tag to remove from all notes.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Tag.guid" - if the guid parameter is missing
  • PERMISSION_DENIED "Tag" - user doesn't own tag
EDAMNotFoundException
  • "Tag.guid" - tag not found, by GUID

◆ untagAllAsync()

virtual AsyncResult* qevercloud::INoteStore::untagAllAsync ( Guid  guid,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of untagAll

◆ updateLinkedNotebook()

virtual qint32 qevercloud::INoteStore::updateLinkedNotebook ( const LinkedNotebook linkedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual
Parameters
linkedNotebookUpdates the name of a linked notebook.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • DATA_REQUIRED "LinkedNotebook.shareName" - missing shareName
  • BAD_DATA_FORMAT "LinkedNotebook.shareName" - invalid shareName length or pattern
  • BAD_DATA_FORMAT "LinkedNotebook.stack" - invalid stack name length or pattern

◆ updateLinkedNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::updateLinkedNotebookAsync ( const LinkedNotebook linkedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateLinkedNotebook

◆ updateNote()

virtual Note qevercloud::INoteStore::updateNote ( const Note note,
IRequestContextPtr  ctx = {} 
)
pure virtual

Submit a set of changes to a note to the service. The provided data must include the note's guid field for identification. The note's title must also be set.

Parameters
noteA Note object containing the desired fields to be populated on the service. With the exception of the note's title and guid, fields that are not being changed do not need to be set. If the content is not being modified, note.content should be left unset. If the list of resources is not being modified, note.resources should be left unset.
Returns
The Note.sharedNotes field will not be set. The service will include the meta-data for each resource in the note, but the binary contents of the resources and their recognition data will be omitted.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Note.title" - invalid length or pattern
  • BAD_DATA_FORMAT "Note.content" - invalid length for ENML body
  • BAD_DATA_FORMAT "NoteAttributes.*" - bad resource string
  • BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
  • BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
  • DATA_CONFLICT "Note.deleted" - deleted time set on active note
  • DATA_REQUIRED "Resource.data" - resource data body missing
  • ENML_VALIDATION "*" - note content doesn't validate against DTD
  • LIMIT_REACHED "Note.tagGuids" - too many Tags on Note
  • LIMIT_REACHED "Note.resources" - too many resources on Note
  • LIMIT_REACHED "Note.size" - total note size too large
  • LIMIT_REACHED "Resource.data.size" - resource too large
  • LIMIT_REACHED "NoteAttribute.*" - attribute string too long
  • LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
  • PERMISSION_DENIED "Note.notebookGuid" - user doesn't own destination
  • PERMISSION_DENIED "Note.tags" - user doesn't have permission to modify the note's tags. note.tags must be unset.
  • PERMISSION_DENIED "Note.attributes" - user doesn't have permission to modify the note's attributes. note.attributes must be unset.
  • QUOTA_REACHED "Accounting.uploadLimit" - note exceeds upload quota
  • BAD_DATA_FORMAT "Tag.name" - Note.tagNames was provided, and one of the specified tags had an invalid length or pattern
  • LIMIT_REACHED "Tag" - Note.tagNames was provided, and the required new tags would exceed the maximum number per account
EDAMNotFoundException
  • "Note.guid" - note not found, by GUID
  • "Note.notebookGuid" - if notebookGuid provided, but not found

◆ updateNoteAsync()

virtual AsyncResult* qevercloud::INoteStore::updateNoteAsync ( const Note note,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateNote

◆ updateNotebook()

virtual qint32 qevercloud::INoteStore::updateNotebook ( const Notebook notebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Submits notebook changes to the service. The provided data must include the notebook's guid field for identification.

The Notebook will be moved to the specified Workspace, if a non empty Notebook.workspaceGuid is provided. If an empty Notebook.workspaceGuid is set and the Notebook is in a Workspace, then it will be removed from the Workspace and a full access SharedNotebook record will be ensured for the caller. If the caller does not already have a full access share, either the privilege of an existing share will be upgraded or a new share will be created. It is illegal to set a Notebook.workspaceGuid on a Workspace backing Notebook.

Parameters
notebookThe notebook object containing the requested changes.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Notebook.name" - invalid length or pattern
  • BAD_DATA_FORMAT "Notebook.stack" - invalid length or pattern
  • BAD_DATA_FORMAT "Publishing.uri" - if publishing set but bad uri
  • BAD_DATA_FORMAT "Publishing.publicDescription" - if too long
  • DATA_CONFLICT "Notebook.name" - name already in use
  • DATA_CONFLICT "Publishing.uri" - if URI already in use
  • DATA_REQUIRED "Publishing.uri" - if publishing set but uri missing
  • DATA_REQUIRED "Notebook" - notebook parameter was null
  • PERMISSION_DENIED "Notebook.defaultNotebook" - if the 'defaultNotebook' field is set to 'true' for a Notebook that is not owned by the user identified by the passed authenticationToken.
EDAMNotFoundException
  • "Notebook.guid" - not found, by GUID
  • "Workspace.guid" - if a non empty workspaceGuid set and no Workspace exists for the GUID

◆ updateNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::updateNotebookAsync ( const Notebook notebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateNotebook

◆ updateNoteIfUsnMatches()

virtual UpdateNoteIfUsnMatchesResult qevercloud::INoteStore::updateNoteIfUsnMatches ( const Note note,
IRequestContextPtr  ctx = {} 
)
pure virtual

Perform the same operation as updateNote() would provided that the update sequence number on the parameter Note object matches the current update sequence number that the service has for the note. If they do not match, then no update is performed and the return value will have the current server state in the note field and updated will be false. If the update sequence numbers between the client and server do match, then the note will be updated and the note field of the return value will be returned as it would be for the updateNote method. This method allows you to check for an update to the note on the service, by another client instance, from when you obtained the note state as a baseline for your edits and the time when you wish to save your edits. If your client can merge the conflict, you can avoid overwriting changes that were saved to the service by the other client.

See the updateNote method for information on the exceptions and parameters for this method. The only difference is that you must have an update sequence number defined on the note parameter (equal to the USN of the note as synched to the client), and the following additional exceptions might be thrown.

Exceptions
EDAMUserException
  • DATA_REQUIRED "Note.updateSequenceNum" - If the update sequence number was not provided. This includes a value that is set as 0.
  • BAD_DATA_FORMAT "Note.updateSequenceNum" - If the note has an update sequence number that is larger than the current server value, which should not happen if your client is working correctly.

◆ updateNoteIfUsnMatchesAsync()

virtual AsyncResult* qevercloud::INoteStore::updateNoteIfUsnMatchesAsync ( const Note note,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateNoteIfUsnMatches

◆ updateResource()

virtual qint32 qevercloud::INoteStore::updateResource ( const Resource resource,
IRequestContextPtr  ctx = {} 
)
pure virtual

Submit a set of changes to a resource to the service. This can be used to update the meta-data about the resource, but cannot be used to change the binary contents of the resource (including the length and hash). These cannot be changed directly without creating a new resource and removing the old one via updateNote.

Parameters
resourceA Resource object containing the desired fields to be populated on the service. The service will attempt to update the resource with the following fields from the client:
  • guid: must be provided to identify the resource
  • mime
  • width
  • height
  • duration
  • attributes: optional. if present, the set of attributes will be replaced.
Returns
The Update Sequence Number of the resource after the changes have been applied.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Resource.guid" - if the parameter is missing
  • BAD_DATA_FORMAT "Resource.mime" - invalid resource MIME type
  • BAD_DATA_FORMAT "ResourceAttributes.*" - bad resource string
  • LIMIT_REACHED "ResourceAttribute.*" - attribute string too long
  • PERMISSION_DENIED "Resource" - private resource, user doesn't own
EDAMNotFoundException
  • "Resource.guid" - not found, by GUID

◆ updateResourceAsync()

virtual AsyncResult* qevercloud::INoteStore::updateResourceAsync ( const Resource resource,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateResource

◆ updateSearch()

virtual qint32 qevercloud::INoteStore::updateSearch ( const SavedSearch search,
IRequestContextPtr  ctx = {} 
)
pure virtual

Submits search changes to the service. The provided data must include the search's guid field for identification. The service will apply updates to the following search fields: name, query, and scope.

Parameters
searchThe search object containing the requested changes.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "SavedSearch.name" - invalid length or pattern
  • BAD_DATA_FORMAT "SavedSearch.query" - invalid length
  • DATA_CONFLICT "SavedSearch.name" - name already in use
  • PERMISSION_DENIED "SavedSearch" - user doesn't own tag
EDAMNotFoundException
  • "SavedSearch.guid" - not found, by GUID

◆ updateSearchAsync()

virtual AsyncResult* qevercloud::INoteStore::updateSearchAsync ( const SavedSearch search,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateSearch

◆ updateSharedNotebook()

virtual qint32 qevercloud::INoteStore::updateSharedNotebook ( const SharedNotebook sharedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

@Deprecated See createOrUpdateNotebookShares and manageNotebookShares.

◆ updateSharedNotebookAsync()

virtual AsyncResult* qevercloud::INoteStore::updateSharedNotebookAsync ( const SharedNotebook sharedNotebook,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateSharedNotebook

◆ updateTag()

virtual qint32 qevercloud::INoteStore::updateTag ( const Tag tag,
IRequestContextPtr  ctx = {} 
)
pure virtual

Submits tag changes to the service. The provided data must include the tag's guid field for identification. The service will apply updates to the following tag fields: name, parentGuid

Parameters
tagThe tag object containing the requested changes.
Returns
The Update Sequence Number for this change within the account.
Exceptions
EDAMUserException
  • BAD_DATA_FORMAT "Tag.name" - invalid length or pattern
  • BAD_DATA_FORMAT "Tag.parentGuid" - malformed GUID
  • DATA_CONFLICT "Tag.name" - name already in use
  • DATA_CONFLICT "Tag.parentGuid" - can't set parent: circular
  • PERMISSION_DENIED "Tag" - user doesn't own tag
EDAMNotFoundException
  • "Tag.guid" - tag not found, by GUID
  • "Tag.parentGuid" - parent not found, by GUID

◆ updateTagAsync()

virtual AsyncResult* qevercloud::INoteStore::updateTagAsync ( const Tag tag,
IRequestContextPtr  ctx = {} 
)
pure virtual

Asynchronous version of updateTag