Merge lp:~mzanetti/reminders-app/create-edit-delete-notes into lp:reminders-app

[Michael Zanetti]

Adds support creating, editing and deleting notes.

Adds support creating, editing and deleting notes. Still a bit experimental. Need to figure a way to deal with the doctype.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:12
http://91.189.93.70:8080/job/reminders-app-ci/13/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/235/console
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/13
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/13
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/13

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/13/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

=== modified file 'src/app/qml/reminders-app.qml'
--- src/app/qml/reminders-app.qml	2013-11-22 00:42:39 +0000
+++ src/app/qml/reminders-app.qml	2013-11-25 00:51:38 +0000
@@ -29,7 +29,7 @@
 
     Component.onCompleted: {
         pagestack.push(rootTabs)
-        if (NotesStore.token.length == 0) {
+        if (NotesStore.token.length === 0) {
             pagestack.push(Qt.resolvedUrl("ui/AccountSelectorPage.qml"));
         }
     }
 
=== modified file 'src/app/qml/ui/NotePage.qml'
--- src/app/qml/ui/NotePage.qml	2013-11-21 23:30:15 +0000
+++ src/app/qml/ui/NotePage.qml	2013-11-25 00:51:38 +0000
@@ -3,13 +3,33 @@
 import Evernote 0.1
 
 Page {
-
-    property alias text: noteTextArea.text
-
-    TextArea {
-        id: noteTextArea
+    title: note.title
+    property var note
+
+    Column {
         anchors.fill: parent
-        textFormat: TextEdit.RichText
+        spacing: units.gu(1)
+        Button {
+            width: parent.width
+            text: "save"
+            onClicked: {
+                print("timer triggered")
+                var content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\"><en-note><div><br clear=\"none\"/>"
+                content = content + noteTextArea.getText(0, noteTextArea.length)
+                content = content + "<br clear=\"none\"/></div><div><br clear=\"none\"/></div></en-note>"
+                note.content = content
+                note.save();
+            }
+        }
+
+        TextArea {
+            id: noteTextArea
+            anchors { left: parent.left; right: parent.right }
+            height: parent.height - y
+
+            textFormat: TextEdit.RichText
+            text: note.content
+        }
     }
 }
 
 
=== modified file 'src/app/qml/ui/NotesPage.qml'
--- src/app/qml/ui/NotesPage.qml	2013-11-21 23:30:15 +0000
+++ src/app/qml/ui/NotesPage.qml	2013-11-25 00:51:38 +0000
@@ -10,14 +10,27 @@
 
     onActiveChanged: {
         if (active) {
+            print("refreshing notes")
             notes.refresh();
         }
     }
 
+    // Just for testing
+    tools: ToolbarItems {
+        ToolbarButton {
+            text: "add note"
+            enabled: notes.filterNotebookGuid.length > 0
+            onTriggered: {
+                var content = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\"><en-note><div><br clear=\"none\"/>"
+                content = content + "fobar"
+                content = content + "<br clear=\"none\"/></div><div><br clear=\"none\"/></div></en-note>"
+                NotesStore.createNote("Untitled", notes.filterNotebookGuid, content);
+            }
+        }
+    }
+
     Notes {
         id: notes
-
-        onFilterNotebookGuidChanged: refresh();
     }
 
     ListView {
@@ -28,7 +41,11 @@
             text: title
 
             onClicked: {
-                pageStack.push(Qt.resolvedUrl("NotePage.qml"), {title: title, text: notes.note(guid)})
+                pageStack.push(Qt.resolvedUrl("NotePage.qml"), {note: notes.note(guid)})
+            }
+
+            onPressAndHold: {
+                notes.note(guid).remove();
             }
         }
     }
 
=== modified file 'src/plugin/Evernote/Evernote.pro'
--- src/plugin/Evernote/Evernote.pro	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/Evernote.pro	2013-11-25 00:51:38 +0000
@@ -13,13 +13,31 @@
     notesstore.cpp \
     userstore.cpp \
     notebooks.cpp \
-    notes.cpp
+    notes.cpp \
+    note.cpp \
+    notebook.cpp \
+    jobs/fetchnotesjob.cpp \
+    jobs/fetchnotebooksjob.cpp \
+    jobs/fetchnotejob.cpp \
+    jobs/createnotejob.cpp \
+    jobs/evernotejob.cpp \
+    jobs/savenotejob.cpp \
+    jobs/deletenotejob.cpp
 
 HEADERS += evernoteplugin.h \
     notesstore.h \
     userstore.h \
     notebooks.h \
-    notes.h
+    notes.h \
+    note.h \
+    notebook.h \
+    jobs/fetchnotesjob.h \
+    jobs/fetchnotebooksjob.h \
+    jobs/fetchnotejob.h \
+    jobs/createnotejob.h \
+    jobs/evernotejob.h \
+    jobs/savenotejob.h \
+    jobs/deletenotejob.h
 
 message(building in $$OUT_PWD)
 LIBS += -L$$OUT_PWD/../../../3rdParty/evernote-sdk-cpp/ -L$$OUT_PWD/../../../3rdParty/libthrift/ -levernote-sdk-cpp -llibthrift
 
=== modified file 'src/plugin/Evernote/evernoteplugin.cpp'
--- src/plugin/Evernote/evernoteplugin.cpp	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/evernoteplugin.cpp	2013-11-25 00:51:38 +0000
@@ -22,6 +22,7 @@
 #include "notesstore.h"
 #include "notes.h"
 #include "notebooks.h"
+#include "note.h"
 
 #include <QtQml>
 
@@ -37,4 +38,5 @@
     qmlRegisterSingletonType<NotesStore>("Evernote", 0, 1, "NotesStore", notesStoreProvider);
     qmlRegisterType<Notes>("Evernote", 0, 1, "Notes");
     qmlRegisterType<Notebooks>("Evernote", 0, 1, "Notebooks");
+    qmlRegisterUncreatableType<Note>("Evernote", 0, 1, "Note", "Cannot create Notes in QML. Use NotesStore.createNote() instead.");
 }
 
=== added directory 'src/plugin/Evernote/jobs'
=== added file 'src/plugin/Evernote/jobs/createnotejob.cpp'
--- src/plugin/Evernote/jobs/createnotejob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/createnotejob.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,37 @@
+#include "createnotejob.h"
+
+#include <QDebug>
+
+CreateNoteJob::CreateNoteJob(Note *note, QObject *parent) :
+    EvernoteJob(parent),
+    m_note(note)
+{
+}
+
+void CreateNoteJob::run()
+{
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+
+    try {
+        evernote::edam::Note input;
+        input.title = m_note->title().toStdString();
+        input.__isset.title = true;
+        input.notebookGuid = m_note->notebookGuid().toStdString();
+        input.__isset.notebookGuid = true;
+        input.content = m_note->content().toStdString();
+        input.__isset.content = true;
+        input.contentLength = m_note->content().length();
+        input.__isset.contentLength = true;
+
+        evernote::edam::Note result;
+        client()->createNote(result, token().toStdString(), input);
+
+        m_note->setGuid(QString::fromStdString(result.guid));
+
+    } catch(evernote::edam::EDAMUserException e) {
+        errorCode = NotesStore::ErrorCodeUserException;
+    } catch(evernote::edam::EDAMSystemException) {
+        errorCode = NotesStore::ErrorCodeSystemException;
+    }
+    emit resultReady(errorCode, m_note);
+}
 
=== added file 'src/plugin/Evernote/jobs/createnotejob.h'
--- src/plugin/Evernote/jobs/createnotejob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/createnotejob.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,22 @@
+#ifndef CREATENOTEJOB_H
+#define CREATENOTEJOB_H
+
+#include "evernotejob.h"
+#include "note.h"
+
+class CreateNoteJob : public EvernoteJob
+{
+    Q_OBJECT
+public:
+    explicit CreateNoteJob(Note *note, QObject *parent = 0);
+
+    void run();
+
+signals:
+    void resultReady(NotesStore::ErrorCode errorCode, Note *note);
+
+private:
+    Note *m_note;
+};
+
+#endif // CREATENOTEJOB_H
 
=== added file 'src/plugin/Evernote/jobs/deletenotejob.cpp'
--- src/plugin/Evernote/jobs/deletenotejob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/deletenotejob.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,18 @@
+#include "deletenotejob.h"
+
+DeleteNoteJob::DeleteNoteJob(const QString &guid, QObject *parent):
+    EvernoteJob(parent),
+    m_guid(guid)
+{
+}
+
+void DeleteNoteJob::run()
+{
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+    try {
+        client()->deleteNote(token().toStdString(), m_guid.toStdString());
+    } catch(...) {
+        catchTransportException();
+    }
+    emit resultReady(errorCode, m_guid);
+}
 
=== added file 'src/plugin/Evernote/jobs/deletenotejob.h'
--- src/plugin/Evernote/jobs/deletenotejob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/deletenotejob.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,21 @@
+#ifndef DELETENOTEJOB_H
+#define DELETENOTEJOB_H
+
+#include "evernotejob.h"
+
+class DeleteNoteJob : public EvernoteJob
+{
+    Q_OBJECT
+public:
+    DeleteNoteJob(const QString &guid, QObject *parent = 0);
+
+    void run();
+
+signals:
+    void resultReady(NotesStore::ErrorCode errorCode, const QString &guid);
+
+private:
+    QString m_guid;
+};
+
+#endif // DELETENOTEJOB_H
 
=== added file 'src/plugin/Evernote/jobs/evernotejob.cpp'
--- src/plugin/Evernote/jobs/evernotejob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/evernotejob.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,49 @@
+#include "evernotejob.h"
+
+// Thrift
+#include <arpa/inet.h> // seems thrift forgot this one
+#include <protocol/TBinaryProtocol.h>
+#include <transport/THttpClient.h>
+#include <transport/TSSLSocket.h>
+#include <Thrift.h>
+
+#include <QDebug>
+
+using namespace apache::thrift;
+using namespace apache::thrift::protocol;
+using namespace apache::thrift::transport;
+
+EvernoteJob::EvernoteJob(QObject *parent) :
+    QThread(parent),
+    m_token(NotesStore::instance()->token())
+{
+    connect(this, &EvernoteJob::finished, this, &EvernoteJob::deleteLater);
+}
+
+EvernoteJob::~EvernoteJob()
+{
+
+}
+
+evernote::edam::NoteStoreClient *EvernoteJob::client()
+{
+    return NotesStore::instance()->m_client;
+}
+
+QString EvernoteJob::token()
+{
+    return m_token;
+}
+
+void EvernoteJob::catchTransportException()
+{
+    try {
+        // this function is meant to be called from a catch block
+        // rethrow the exception to catch it again
+        throw;
+    } catch (const TTransportException & e) {
+        qDebug() <<  e.what();
+    } catch (const TException & e) {
+        qDebug() <<  e.what();
+    }
+}
 
=== added file 'src/plugin/Evernote/jobs/evernotejob.h'
--- src/plugin/Evernote/jobs/evernotejob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/evernotejob.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,30 @@
+#ifndef EVERNOTEJOB_H
+#define EVERNOTEJOB_H
+
+#include "notesstore.h"
+
+// Evernote SDK
+#include <NoteStore.h>
+#include <NoteStore_constants.h>
+#include <Errors_types.h>
+
+#include <QThread>
+
+class EvernoteJob : public QThread
+{
+    Q_OBJECT
+public:
+    explicit EvernoteJob(QObject *parent = 0);
+    virtual ~EvernoteJob();
+
+protected:
+    evernote::edam::NoteStoreClient* client();
+    QString token();
+
+    void catchTransportException();
+
+private:
+    QString m_token;
+};
+
+#endif // EVERNOTEJOB_H
 
=== added file 'src/plugin/Evernote/jobs/fetchnotebooksjob.cpp'
--- src/plugin/Evernote/jobs/fetchnotebooksjob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/fetchnotebooksjob.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,23 @@
+#include "fetchnotebooksjob.h"
+
+#include <QDebug>
+
+FetchNotebooksJob::FetchNotebooksJob(QObject *parent) :
+    EvernoteJob(parent)
+{
+}
+
+
+void FetchNotebooksJob::run()
+{
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+    std::vector<evernote::edam::Notebook> results;
+    try {
+        client()->listNotebooks(results, token().toStdString());
+    } catch(evernote::edam::EDAMUserException) {
+        errorCode = NotesStore::ErrorCodeUserException;
+    } catch(evernote::edam::EDAMSystemException) {
+        errorCode = NotesStore::ErrorCodeSystemException;
+    }
+    emit resultReady(errorCode, results);
+}
 
=== added file 'src/plugin/Evernote/jobs/fetchnotebooksjob.h'
--- src/plugin/Evernote/jobs/fetchnotebooksjob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/fetchnotebooksjob.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,18 @@
+#ifndef FETCHNOTEBOOKSJOB_H
+#define FETCHNOTEBOOKSJOB_H
+
+#include "evernotejob.h"
+
+class FetchNotebooksJob : public EvernoteJob
+{
+    Q_OBJECT
+public:
+    explicit FetchNotebooksJob(QObject *parent = 0);
+
+    void run();
+
+signals:
+    void resultReady(NotesStore::ErrorCode errorCode, const std::vector<evernote::edam::Notebook> &results);
+};
+
+#endif // FETCHNOTEBOOKSJOB_H
 
=== added file 'src/plugin/Evernote/jobs/fetchnotejob.cpp'
--- src/plugin/Evernote/jobs/fetchnotejob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/fetchnotejob.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,27 @@
+#include "fetchnotejob.h"
+
+FetchNoteJob::FetchNoteJob(const QString &guid, QObject *parent) :
+    EvernoteJob(parent),
+    m_guid(guid)
+{
+}
+
+void FetchNoteJob::run()
+{
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+    evernote::edam::Note result;
+    try {
+        client()->getNote(result, token().toStdString(), m_guid.toStdString(), true, true, false, false);
+    } catch (evernote::edam::EDAMUserException) {
+        errorCode = NotesStore::ErrorCodeUserException;
+    } catch (evernote::edam::EDAMSystemException) {
+        errorCode = NotesStore::ErrorCodeSystemException;
+    } catch (evernote::edam::EDAMNotFoundException) {
+        errorCode = NotesStore::ErrorCodeNotFoundExcpetion;
+    } catch (...) {
+        catchTransportException();
+        errorCode = NotesStore::ErrorCodeConnectionLost;
+    }
+
+    emit resultReady(errorCode, result);
+}
 
=== added file 'src/plugin/Evernote/jobs/fetchnotejob.h'
--- src/plugin/Evernote/jobs/fetchnotejob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/fetchnotejob.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,22 @@
+#ifndef FETCHNOTEJOB_H
+#define FETCHNOTEJOB_H
+
+#include "evernotejob.h"
+
+class FetchNoteJob : public EvernoteJob
+{
+    Q_OBJECT
+public:
+    explicit FetchNoteJob(const QString &guid, QObject *parent = 0);
+
+    void run();
+signals:
+    void resultReady(NotesStore::ErrorCode error, const evernote::edam::Note &note);
+
+private:
+    evernote::edam::NoteStoreClient *m_client;
+    QString m_token;
+    QString m_guid;
+};
+
+#endif // FETCHNOTEJOB_H
 
=== added file 'src/plugin/Evernote/jobs/fetchnotesjob.cpp'
--- src/plugin/Evernote/jobs/fetchnotesjob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/fetchnotesjob.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,44 @@
+#include "fetchnotesjob.h"
+
+#include "notesstore.h"
+
+#include <QDebug>
+
+FetchNotesJob::FetchNotesJob( const QString &filterNotebookGuid, QObject *parent) :
+    EvernoteJob(parent),
+    m_filterNotebookGuid(filterNotebookGuid)
+{
+}
+
+void FetchNotesJob::run()
+{
+    // TODO: fix start/end (use smaller chunks and continue fetching if there are more notes available)
+    int32_t start = 0;
+    int32_t end = 10000;
+
+    // Prepare filter
+    evernote::edam::NoteFilter filter;
+    filter.notebookGuid = m_filterNotebookGuid.toStdString();
+    filter.__isset.notebookGuid = !m_filterNotebookGuid.isEmpty();
+
+    // Prepare ResultSpec
+    evernote::edam::NotesMetadataResultSpec resultSpec;
+    resultSpec.includeNotebookGuid = true;
+    resultSpec.__isset.includeNotebookGuid = true;
+    resultSpec.includeTitle = true;
+    resultSpec.__isset.includeTitle = true;
+
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+    evernote::edam::NotesMetadataList results;
+
+    try {
+        client()->findNotesMetadata(results, token().toStdString(), filter, start, end, resultSpec);
+    } catch(evernote::edam::EDAMUserException) {
+        errorCode = NotesStore::ErrorCodeUserException;
+    } catch(evernote::edam::EDAMSystemException) {
+        errorCode = NotesStore::ErrorCodeSystemException;
+    } catch(evernote::edam::EDAMNotFoundException) {
+        errorCode = NotesStore::ErrorCodeNotFoundExcpetion;
+    }
+    emit resultReady(errorCode, results);
+}
 
=== added file 'src/plugin/Evernote/jobs/fetchnotesjob.h'
--- src/plugin/Evernote/jobs/fetchnotesjob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/fetchnotesjob.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,21 @@
+#ifndef FETCHNOTESJOB_H
+#define FETCHNOTESJOB_H
+
+#include "evernotejob.h"
+
+class FetchNotesJob : public EvernoteJob
+{
+    Q_OBJECT
+public:
+    explicit FetchNotesJob(const QString &filterNotebookGuid, QObject *parent = 0);
+
+    void run();
+
+signals:
+    void resultReady(NotesStore::ErrorCode errorCode, const evernote::edam::NotesMetadataList &results);
+
+private:
+    QString m_filterNotebookGuid;
+};
+
+#endif // FETCHNOTESJOB_H
 
=== added file 'src/plugin/Evernote/jobs/savenotejob.cpp'
--- src/plugin/Evernote/jobs/savenotejob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/savenotejob.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,40 @@
+#include "savenotejob.h"
+#include "note.h"
+
+#include <QDebug>
+
+SaveNoteJob::SaveNoteJob(Note *note, QObject *parent) :
+    EvernoteJob(parent),
+    m_note(note)
+{
+}
+
+void SaveNoteJob::run()
+{
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+    try {
+        evernote::edam::Note note;
+        note.guid = m_note->guid().toStdString();
+        note.__isset.guid = true;
+        note.title = m_note->title().toStdString();
+        note.__isset.title = true;
+        note.notebookGuid = m_note->notebookGuid().toStdString();
+        note.__isset.notebookGuid = true;
+        note.content = m_note->content().toStdString();
+        note.__isset.content = true;
+        note.contentLength = m_note->content().length();
+
+        client()->updateNote(note, token().toStdString(), note);
+
+    } catch (evernote::edam::EDAMUserException e) {
+        errorCode = NotesStore::ErrorCodeUserException;
+        qDebug() << QString::fromStdString(e.parameter);
+    } catch (evernote::edam::EDAMSystemException) {
+        errorCode = NotesStore::ErrorCodeSystemException;
+    } catch (...) {
+        catchTransportException();
+        errorCode = NotesStore::ErrorCodeConnectionLost;
+    }
+
+    emit resultReady(errorCode, m_note);
+}
 
=== added file 'src/plugin/Evernote/jobs/savenotejob.h'
--- src/plugin/Evernote/jobs/savenotejob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/jobs/savenotejob.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,20 @@
+#ifndef SAVENOTEJOB_H
+#define SAVENOTEJOB_H
+
+#include "evernotejob.h"
+
+class SaveNoteJob : public EvernoteJob
+{
+    Q_OBJECT
+public:
+    explicit SaveNoteJob(Note *note, QObject *parent = 0);
+
+    void run();
+signals:
+    void resultReady(NotesStore::ErrorCode errorCode, Note *note);
+
+private:
+    Note *m_note;
+};
+
+#endif // SAVENOTEJOB_H
 
=== added file 'src/plugin/Evernote/note.cpp'
--- src/plugin/Evernote/note.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/note.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,71 @@
+#include "note.h"
+
+#include "notesstore.h"
+
+Note::Note(const QString &guid, QObject *parent) :
+    QObject(parent),
+    m_guid(guid)
+{
+}
+
+QString Note::guid() const
+{
+    return m_guid;
+}
+
+void Note::setGuid(const QString &guid)
+{
+    if (m_guid == guid) {
+        m_guid = guid;
+        emit guidChanged();
+    }
+}
+
+QString Note::notebookGuid() const
+{
+    return m_notebookGuid;
+}
+
+void Note::setNotebookGuid(const QString &notebookGuid)
+{
+    if (m_notebookGuid != notebookGuid) {
+        m_notebookGuid = notebookGuid;
+        emit notebookGuidChanged();
+    }
+}
+
+QString Note::title() const
+{
+    return m_title;
+}
+
+void Note::setTitle(const QString &title)
+{
+    if (m_title != title) {
+        m_title = title;
+        emit titleChanged();
+    }
+}
+
+QString Note::content() const
+{
+    return m_content;
+}
+
+void Note::setContent(const QString &content)
+{
+    if (m_content != content) {
+        m_content = content;
+        emit contentChanged();
+    }
+}
+
+void Note::save()
+{
+    NotesStore::instance()->saveNote(m_guid);
+}
+
+void Note::remove()
+{
+    NotesStore::instance()->deleteNote(m_guid);
+}
 
=== added file 'src/plugin/Evernote/note.h'
--- src/plugin/Evernote/note.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/note.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,46 @@
+#ifndef NOTE_H
+#define NOTE_H
+
+#include <QObject>
+
+class Note : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString guid READ guid NOTIFY guidChanged)
+    Q_PROPERTY(QString notebookGuid READ notebookGuid WRITE setNotebookGuid NOTIFY notebookGuidChanged)
+    Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged)
+    Q_PROPERTY(QString content READ content WRITE setContent NOTIFY contentChanged)
+public:
+    explicit Note(const QString &guid = QString(), QObject *parent = 0);
+
+    QString guid() const;
+    void setGuid(const QString &guid);
+
+    QString notebookGuid() const;
+    void setNotebookGuid(const QString &notebookGuid);
+
+    QString title() const;
+    void setTitle(const QString &title);
+
+    QString content() const;
+    void setContent(const QString &content);
+
+public slots:
+    void save();
+    void remove();
+
+signals:
+    void guidChanged();
+    void titleChanged();
+    void notebookGuidChanged();
+    void contentChanged();
+
+private:
+    QString m_guid;
+    QString m_notebookGuid;
+    QString m_title;
+    QString m_content;
+};
+
+#endif // NOTE_H
 
=== added file 'src/plugin/Evernote/notebook.cpp'
--- src/plugin/Evernote/notebook.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/notebook.cpp	2013-11-25 00:51:38 +0000
@@ -0,0 +1,25 @@
+#include "notebook.h"
+
+Notebook::Notebook(QString guid, QObject *parent) :
+    QObject(parent),
+    m_guid(guid)
+{
+}
+
+QString Notebook::guid() const
+{
+    return m_guid;
+}
+
+QString Notebook::name() const
+{
+    return m_name;
+}
+
+void Notebook::setName(const QString &name)
+{
+    if (m_name != name) {
+        m_name = name;
+        emit nameChanged();
+    }
+}
 
=== added file 'src/plugin/Evernote/notebook.h'
--- src/plugin/Evernote/notebook.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/notebook.h	2013-11-25 00:51:38 +0000
@@ -0,0 +1,30 @@
+#ifndef NOTEBOOK_H
+#define NOTEBOOK_H
+
+#include <QObject>
+
+class Notebook : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString guid READ guid CONSTANT)
+    Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
+public:
+    explicit Notebook(QString guid, QObject *parent = 0);
+
+    QString guid() const;
+
+    QString name() const;
+    void setName(const QString &name);
+
+signals:
+    void nameChanged();
+
+public slots:
+
+private:
+    QString m_guid;
+    QString m_name;
+};
+
+#endif // NOTEBOOK_H
 
=== modified file 'src/plugin/Evernote/notebooks.cpp'
--- src/plugin/Evernote/notebooks.cpp	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/notebooks.cpp	2013-11-25 00:51:38 +0000
@@ -1,27 +1,34 @@
 #include "notebooks.h"
+#include "notebook.h"
 
 #include <QDebug>
 
 Notebooks::Notebooks(QObject *parent) :
     QAbstractListModel(parent)
 {
+    foreach (Notebook *notebook, NotesStore::instance()->notebooks()) {
+        m_list.append(notebook->guid());
+    }
+
+    connect(NotesStore::instance(), SIGNAL(notebookAdded(const QString &)), SLOT(notebookAdded(const QString &)));
 }
 
 QVariant Notebooks::data(const QModelIndex &index, int role) const
 {
+
+    Notebook *notebook = NotesStore::instance()->notebook(m_list.at(index.row()));
     switch(role) {
     case RoleGuid:
-        return QString::fromStdString(m_list.at(index.row()).guid);
+        return notebook->guid();
     case RoleName:
-        return QString::fromStdString(m_list.at(index.row()).name);
+        return notebook->name();
     }
-
     return QVariant();
 }
 
 int Notebooks::rowCount(const QModelIndex &parent) const
 {
-    return m_list.size();
+    return m_list.count();
 }
 
 QHash<int, QByteArray> Notebooks::roleNames() const
@@ -34,25 +41,12 @@
 
 void Notebooks::refresh()
 {
-
-    QString token = NotesStore::instance()->token();
-    if (token.isEmpty()) {
-        qDebug() << "No token set. Cannot fetch notebooks.";
-        return;
-    }
-
-    beginResetModel();
-    try {
-        NotesStore::instance()->evernoteNotesStoreClient()->listNotebooks(m_list, token.toStdString());
-    } catch(...) {
-        qDebug() << "Error fetching notebooks.";
-//        displayException();
-    }
-
-    endResetModel();
-
-//    for (int i = 0; i < notebooks.size(); ++i) {
-//        qDebug() << "got notebooks" << QString::fromStdString(notebooks.at(i).name) << QString::fromStdString(notebooks.at(i).name)
-//                 << QString::fromStdString(notebooks.at(i).guid);
-//    }
+    NotesStore::instance()->refreshNotebooks();
+}
+
+void Notebooks::notebookAdded(const QString &guid)
+{
+    beginInsertRows(QModelIndex(), m_list.count(), m_list.count());
+    m_list.append(guid);
+    endInsertRows();
 }
 
=== modified file 'src/plugin/Evernote/notebooks.h'
--- src/plugin/Evernote/notebooks.h	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/notebooks.h	2013-11-25 00:51:38 +0000
@@ -5,8 +5,6 @@
 
 #include <QAbstractListModel>
 
-using namespace evernote::edam;
-
 class Notebooks : public QAbstractListModel
 {
     Q_OBJECT
@@ -24,10 +22,11 @@
 public slots:
     void refresh();
 
+private slots:
+    void notebookAdded(const QString &guid);
+
 private:
-    std::vector<Notebook> m_list;
-
-
+    QList<QString> m_list;
 };
 
 #endif // NOTEBOOKS_H
 
=== modified file 'src/plugin/Evernote/notes.cpp'
--- src/plugin/Evernote/notes.cpp	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/notes.cpp	2013-11-25 00:51:38 +0000
@@ -1,19 +1,24 @@
 #include "notes.h"
+#include "note.h"
 
 #include <QDebug>
 
 Notes::Notes(QObject *parent) :
     QAbstractListModel(parent)
 {
+    connect(NotesStore::instance(), &NotesStore::noteAdded, this, &Notes::noteAdded);
+    connect(NotesStore::instance(), &NotesStore::noteRemoved, this, &Notes::noteRemoved);
+    connect(NotesStore::instance(), &NotesStore::noteChanged, this, &Notes::noteChanged);
 }
 
 QVariant Notes::data(const QModelIndex &index, int role) const
 {
+    Note *note = NotesStore::instance()->note(m_list.at(index.row()));
     switch(role) {
     case RoleGuid:
-        return QString::fromStdString(m_list.at(index.row()).guid);
+        return note->guid();
     case RoleTitle:
-        return QString::fromStdString(m_list.at(index.row()).title);
+        return note->title();
     }
 
     return QVariant();
@@ -45,59 +50,50 @@
     }
 }
 
-QString Notes::note(const QString &noteGuid)
-{
-    QString token = NotesStore::instance()->token();
-    if (token.isEmpty()) {
-        qDebug() << "No token set. Cannot fetch note.";
-        return QString();
-    }
-
-    Note note;
-    try {
-        NotesStore::instance()->evernoteNotesStoreClient()->getNote(note, token.toStdString(), noteGuid.toStdString(), true, true, false, false);
-    } catch(...) {
-        qDebug() << "error fetching note";
-        return QString();
-    }
-
-    return QString::fromStdString(note.content);
+Note* Notes::note(const QString &guid)
+{
+    NotesStore::instance()->refreshNoteContent(guid);
+    return NotesStore::instance()->note(guid);
+}
+
+void Notes::componentComplete()
+{
+    foreach (Note *note, NotesStore::instance()->notes()) {
+        if (m_filterNotebookGuid.isEmpty() || note->notebookGuid() == m_filterNotebookGuid) {
+            m_list.append(note->guid());
+        }
+    }
+    beginInsertRows(QModelIndex(), 0, m_list.count() - 1);
+    endInsertRows();
+    refresh();
 }
 
 void Notes::refresh()
 {
-    QString token = NotesStore::instance()->token();
-    if (token.isEmpty()) {
-        qDebug() << "No token set. Cannot fetch notes.";
-        return;
-    }
-
-    int32_t start = 0;
-    int32_t end = 10000;
-
-    // Prepare filter
-    NoteFilter filter;
-    filter.notebookGuid = m_filterNotebookGuid.toStdString();
-    filter.__isset.notebookGuid = !m_filterNotebookGuid.isEmpty();
-
-    // Prepare ResultSpec
-    NotesMetadataResultSpec resultSpec;
-    resultSpec.includeTitle = true;
-    resultSpec.__isset.includeTitle = true;
-
-    NotesMetadataList notes;
-    try {
-        NotesStore::instance()->evernoteNotesStoreClient()->findNotesMetadata(notes, token.toStdString(), filter, start, end, resultSpec);
-    } catch(...) {
-        qDebug() << "error fetching notes";
-        return;
-    }
-
-    beginResetModel();
-    m_list.clear();
-    foreach (NoteMetadata note, notes.notes) {
-        m_list.append(note);
-        qDebug() << QString::fromStdString(note.guid) << QString::fromStdString(note.title);
-    }
-    endResetModel();
+    NotesStore::instance()->refreshNotes(m_filterNotebookGuid);
+}
+
+void Notes::noteAdded(const QString &guid)
+{
+    beginInsertRows(QModelIndex(), m_list.count(), m_list.count());
+    m_list.append(guid);
+    endInsertRows();
+}
+
+void Notes::noteChanged(const QString &guid)
+{
+    int row = m_list.indexOf(guid);
+    if (row >= 0) {
+        emit dataChanged(index(row), index(row));
+    }
+}
+
+void Notes::noteRemoved(const QString &guid)
+{
+    int index = m_list.indexOf(guid);
+    if (index >= 0) {
+        beginRemoveRows(QModelIndex(), index, index);
+        m_list.removeAt(index);
+        endRemoveRows();
+    }
 }
 
=== modified file 'src/plugin/Evernote/notes.h'
--- src/plugin/Evernote/notes.h	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/notes.h	2013-11-25 00:51:38 +0000
@@ -4,10 +4,9 @@
 #include "notesstore.h"
 
 #include <QAbstractListModel>
-
-using namespace evernote::edam;
-
-class Notes : public QAbstractListModel
+#include <QQmlParserStatus>
+
+class Notes : public QAbstractListModel, public QQmlParserStatus
 {
     Q_OBJECT
     Q_PROPERTY(QString filterNotebookGuid READ filterNotebookGuid WRITE setFilterNotebookGuid NOTIFY filterNotebookGuidChanged)
@@ -25,16 +24,24 @@
     QString filterNotebookGuid() const;
     void setFilterNotebookGuid(const QString &notebookGuid);
 
-    Q_INVOKABLE QString note(const QString &noteGuid);
+    Q_INVOKABLE Note* note(const QString &guid);
+
+    void classBegin() {}
+    void componentComplete();
 
 public slots:
     void refresh();
 
+private slots:
+    void noteAdded(const QString &guid);
+    void noteChanged(const QString &guid);
+    void noteRemoved(const QString &guid);
+
 signals:
     void filterNotebookGuidChanged();
 
 private:
-    QList<NoteMetadata> m_list;
+    QList<QString> m_list;
     QString m_filterNotebookGuid;
 
 };
 
=== modified file 'src/plugin/Evernote/notesstore.cpp'
--- src/plugin/Evernote/notesstore.cpp	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/notesstore.cpp	2013-11-25 00:51:38 +0000
@@ -1,6 +1,14 @@
 #include "notesstore.h"
-
 #include "notebooks.h"
+#include "notebook.h"
+#include "note.h"
+
+#include "jobs/fetchnotesjob.h"
+#include "jobs/fetchnotebooksjob.h"
+#include "jobs/fetchnotejob.h"
+#include "jobs/createnotejob.h"
+#include "jobs/savenotejob.h"
+#include "jobs/deletenotejob.h"
 
 // Thrift
 #include <arpa/inet.h> // seems thrift forgot this one
@@ -11,7 +19,6 @@
 
 #include <QDebug>
 
-using namespace evernote::edam;
 using namespace apache::thrift;
 using namespace apache::thrift::protocol;
 using namespace apache::thrift::transport;
@@ -19,11 +26,10 @@
 NotesStore* NotesStore::s_instance = 0;
 
 NotesStore::NotesStore(QObject *parent) :
-    QObject(parent)
+    QObject(parent),
+    m_currentJob(0)
 {
     try {
-        // TODO: Move this to a common place instead of keeping a copy here and in UserStore
-
         // FIXME: need to populate this string from the system
         // The structure should be:
         // application/version; platform/version; [ device/version ]
@@ -54,13 +60,21 @@
         userStoreHttpClient->open();
 
         boost::shared_ptr<TProtocol> iprot(new TBinaryProtocol(userStoreHttpClient));
-        m_client = new NoteStoreClient(iprot);
+        m_client = new evernote::edam::NoteStoreClient(iprot);
 
         qDebug() << "NoteStore client created.";
-    } catch(...) {
-        displayException();
+
+    } catch (const TTransportException & e) {
+        qWarning() << "Failed to create Transport:" <<  e.what();
+    } catch (const TException & e) {
+        qWarning() << "Generic Thrift exception:" << e.what();
     }
 
+    qRegisterMetaType<NotesStore::ErrorCode>("NotesStore::ErrorCode");
+    qRegisterMetaType<evernote::edam::NotesMetadataList>("evernote::edam::NotesMetadataList");
+    qRegisterMetaType<evernote::edam::Note>("evernote::edam::Note");
+    qRegisterMetaType<std::vector<evernote::edam::Notebook> >("std::vector<evernote::edam::Notebook>");
+
 }
 
 NotesStore *NotesStore::instance()
@@ -71,6 +85,21 @@
     return s_instance;
 }
 
+QString NotesStore::errorCodeToString(NotesStore::ErrorCode errorCode)
+{
+    switch(errorCode) {
+    case ErrorCodeNoError:
+        return QStringLiteral("No error");
+    case ErrorCodeUserException:
+        return QStringLiteral("User exception");
+    case ErrorCodeSystemException:
+        return QStringLiteral("System exception");
+    case ErrorCodeNotFoundExcpetion:
+        return QStringLiteral("Not found");
+    }
+    return QString();
+}
+
 NotesStore::~NotesStore()
 {
     delete m_client;
@@ -84,56 +113,223 @@
 void NotesStore::setToken(const QString &token)
 {
     if (token != m_token) {
-        qDebug() << "NotesStore: setting token:" << token;
         m_token = token;
         emit tokenChanged();
-    }
-}
-
-NoteStoreClient *NotesStore::evernoteNotesStoreClient()
-{
-    return m_client;
-}
-
-// TODO: move to a common place instead of copying it through *store.cpps
-void NotesStore::displayException()
-{
-    QString error_message = "Unknown Exception";
-    try
-    {
-        // this function is meant to be called from a catch block
-        // rethrow the exception to catch it again
-        throw;
-    }
-    catch (const EDAMNotFoundException & e)
-    {
-        qDebug() <<  e.what();
-    }
-    catch (const EDAMSystemException & e)
-    {
-        qDebug() <<  e.what();
-    }
-    catch (const EDAMUserException & e)
-    {
-        qDebug() <<  e.what();
-    }
-    catch (const TTransportException & e)
-    {
-        qDebug() <<  e.what();
-    }
-    catch (const TException & e)
-    {
-        qDebug() <<  e.what();
-    }
-    catch (const std::exception & e)
-    {
-        qDebug() <<  e.what();
-    }
-    catch (...)
-    {
-        error_message = "Tried to sync, but something went wrong.\n Unknown exception.";
-    }
-
-    qDebug() << error_message;
-    disconnect();
-}
+        refreshNotebooks();
+        refreshNotes();
+    }
+}
+
+QList<Note*> NotesStore::notes() const
+{
+    return m_notes.values();
+}
+
+Note *NotesStore::note(const QString &guid)
+{
+    return m_notes.value(guid);
+}
+
+void NotesStore::saveNote(const QString &guid)
+{
+    Note *note = m_notes.value(guid);
+    SaveNoteJob *job = new SaveNoteJob(note, this);
+    connect(job, &SaveNoteJob::resultReady, this, &NotesStore::saveNoteJobDone);
+    m_jobQueue.append(job);
+    startJobQueue();
+}
+
+void NotesStore::deleteNote(const QString &guid)
+{
+    DeleteNoteJob *job = new DeleteNoteJob(guid, this);
+    connect(job, &DeleteNoteJob::resultReady, this, &NotesStore::deleteNoteJobDone);
+    m_jobQueue.append(job);
+    startJobQueue();
+}
+
+QList<Notebook *> NotesStore::notebooks() const
+{
+    return m_notebooks.values();
+}
+
+Notebook *NotesStore::notebook(const QString &guid)
+{
+    return m_notebooks.value(guid);
+}
+
+void NotesStore::startJobQueue()
+{
+    if (m_jobQueue.isEmpty()) {
+        return;
+    }
+
+    if (m_currentJob) {
+        return;
+    }
+    m_currentJob = m_jobQueue.takeFirst();
+    m_currentJob->start();
+}
+
+void NotesStore::startNextJob()
+{
+    m_currentJob = 0;
+    startJobQueue();
+}
+
+void NotesStore::refreshNotes(const QString &filterNotebookGuid)
+{
+    if (m_token.isEmpty()) {
+        qWarning() << "No token set. Cannot fetch notes.";
+        return;
+    }
+
+    FetchNotesJob *job = new FetchNotesJob(filterNotebookGuid);
+    connect(job, &FetchNotesJob::resultReady, this, &NotesStore::fetchNotesJobDone);
+
+    m_jobQueue.append(job);
+    startJobQueue();
+}
+
+void NotesStore::fetchNotesJobDone(ErrorCode errorCode, const evernote::edam::NotesMetadataList &results)
+{
+    if (errorCode != ErrorCodeNoError) {
+        qWarning() << "Failed to fetch notes list:" << errorCodeToString(errorCode);
+        startNextJob();
+        return;
+    }
+
+    for (int i = 0; i < results.notes.size(); ++i) {
+        evernote::edam::NoteMetadata result = results.notes.at(i);
+        Note *note = m_notes.value(QString::fromStdString(result.guid));
+        if (note) {
+            note->setTitle(QString::fromStdString(result.title));
+            note->setNotebookGuid(QString::fromStdString(result.notebookGuid));
+            emit noteChanged(note->guid());
+        } else {
+            note = new Note(QString::fromStdString(result.guid), this);
+            note->setNotebookGuid(QString::fromStdString(result.notebookGuid));
+            note->setTitle(QString::fromStdString(result.title));
+            m_notes.insert(note->guid(), note);
+            emit noteAdded(note->guid());
+        }
+    }
+
+    startNextJob();
+}
+
+void NotesStore::refreshNoteContent(const QString &guid)
+{
+    if (m_token.isEmpty()) {
+        qWarning() << "No token set. Cannot fetch note.";
+        return;
+    }
+
+    FetchNoteJob *job = new FetchNoteJob(guid, this);
+    connect(job, &FetchNoteJob::resultReady, this, &NotesStore::fetchNoteJobDone);
+    m_jobQueue.append(job);
+
+    startJobQueue();
+}
+
+void NotesStore::fetchNoteJobDone(ErrorCode errorCode, const evernote::edam::Note &result)
+{
+    if (errorCode != ErrorCodeNoError) {
+        qWarning() << "Error fetching note:" << errorCode;
+        startNextJob();
+        return;
+    }
+
+    Note *note = m_notes.value(QString::fromStdString(result.guid));
+    note->setNotebookGuid(QString::fromStdString(result.notebookGuid));
+    note->setTitle(QString::fromStdString(result.title));
+    note->setContent(QString::fromStdString(result.content));
+    emit noteChanged(note->guid());
+
+    startNextJob();
+}
+
+void NotesStore::refreshNotebooks()
+{
+    if (m_token.isEmpty()) {
+        qWarning() << "No token set. Cannot refresh notebooks.";
+        return;
+    }
+
+    FetchNotebooksJob *job = new FetchNotebooksJob();
+    connect(job, &FetchNotebooksJob::resultReady, this, &NotesStore::fetchNotebooksJobDone);
+
+    m_jobQueue.append(job);
+    startJobQueue();
+}
+
+void NotesStore::fetchNotebooksJobDone(ErrorCode errorCode, const std::vector<evernote::edam::Notebook> &results)
+{
+    if (errorCode != ErrorCodeNoError) {
+        qWarning() << "Error fetching notebooks:" << errorCodeToString(errorCode);
+        startNextJob();
+        return;
+    }
+
+    for (int i = 0; i < results.size(); ++i) {
+        evernote::edam::Notebook result = results.at(i);
+        Notebook *notebook = m_notebooks.value(QString::fromStdString(result.guid));
+        if (notebook) {
+            qDebug() << "got notebook update";
+            notebook->setName(QString::fromStdString(result.name));
+            emit notebookChanged(notebook->guid());
+        } else {
+            notebook = new Notebook(QString::fromStdString(result.guid), this);
+            notebook->setName(QString::fromStdString(result.name));
+            m_notebooks.insert(notebook->guid(), notebook);
+            emit notebookAdded(notebook->guid());
+            qDebug() << "got new notebook" << notebook->guid();
+        }
+    }
+
+    startNextJob();
+}
+
+void NotesStore::createNote(const QString &title, const QString &notebookGuid, const QString &content)
+{
+    Note *note = new Note();
+    note->setTitle(title);
+    note->setNotebookGuid(notebookGuid);
+    note->setContent(content);
+    CreateNoteJob *job = new CreateNoteJob(note);
+    connect(job, &CreateNoteJob::resultReady, this, &NotesStore::createNoteJobDone);
+
+    m_jobQueue.append(job);
+    startJobQueue();
+}
+
+void NotesStore::createNoteJobDone(NotesStore::ErrorCode errorCode, Note *note)
+{
+    if (errorCode != ErrorCodeNoError) {
+        qWarning() << "Error creating note:" << errorCodeToString(errorCode);
+        delete note;
+        startNextJob();
+        return;
+    }
+
+    m_notes.insert(note->guid(), note);
+    noteAdded(note->guid());
+    startNextJob();
+}
+
+void NotesStore::saveNoteJobDone(NotesStore::ErrorCode errorCode, Note *note)
+{
+    startNextJob();
+}
+
+void NotesStore::deleteNoteJobDone(NotesStore::ErrorCode errorCode, const QString &guid)
+{
+    if (errorCode != ErrorCodeNoError) {
+        qWarning() << "Cannot delete note:" << errorCodeToString(errorCode);
+        startNextJob();
+        return;
+    }
+    emit noteRemoved(guid);
+    m_notes.take(guid)->deleteLater();
+    startNextJob();
+}
+
 
=== modified file 'src/plugin/Evernote/notesstore.h'
--- src/plugin/Evernote/notesstore.h	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/notesstore.h	2013-11-25 00:51:38 +0000
@@ -6,42 +6,85 @@
 #include <NoteStore_constants.h>
 #include <Errors_types.h>
 
-// Qt
 #include <QObject>
-
-using namespace evernote::edam;
-
-class Notebooks;
+#include <QHash>
+
+class EvernoteJob;
+
+class Notebook;
+class Note;
 
 class NotesStore : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString token READ token WRITE setToken NOTIFY tokenChanged)
 
+    friend class EvernoteJob;
+
 public:
+    enum ErrorCode {
+        ErrorCodeNoError,
+        ErrorCodeUserException,
+        ErrorCodeSystemException,
+        ErrorCodeNotFoundExcpetion,
+        ErrorCodeConnectionLost
+    };
+
+    Q_INVOKABLE void createNote(const QString &title, const QString &notebookGuid, const QString &content);
+
     static NotesStore *instance();
+    static QString errorCodeToString(ErrorCode errorCode);
 
     ~NotesStore();
 
     QString token() const;
     void setToken(const QString &token);
 
-    NoteStoreClient *evernoteNotesStoreClient();
-
-private:
-    explicit NotesStore(QObject *parent = 0);
+    QList<Note*> notes() const;
+    Note* note(const QString &guid);
+    void saveNote(const QString &guid);
+    void deleteNote(const QString &guid);
+
+    QList<Notebook*> notebooks() const;
+    Notebook* notebook(const QString &guid);
+
+    void refreshNotes(const QString &filterNotebookGuid = QString());
+    void refreshNoteContent(const QString &guid);
+    void refreshNotebooks();
 
 signals:
     void tokenChanged();
 
+    void noteAdded(const QString &guid);
+    void noteChanged(const QString &guid);
+    void noteRemoved(const QString &guid);
+
+    void notebookAdded(const QString &guid);
+    void notebookChanged(const QString &guid);
+
+private slots:
+    void fetchNotesJobDone(ErrorCode errorCode, const evernote::edam::NotesMetadataList &results);
+    void fetchNotebooksJobDone(ErrorCode errorCode, const std::vector<evernote::edam::Notebook> &results);
+    void fetchNoteJobDone(ErrorCode errorCode, const evernote::edam::Note &result);
+    void createNoteJobDone(ErrorCode errorCode, Note *note);
+    void saveNoteJobDone(ErrorCode errorCode, Note *note);
+    void deleteNoteJobDone(ErrorCode errorCode, const QString &guid);
+
+    void startJobQueue();
+    void startNextJob();
+
 private:
+    explicit NotesStore(QObject *parent = 0);
     static NotesStore *s_instance;
 
-    void displayException();
-
     QString m_token;
-    NoteStoreClient *m_client;
-
+    evernote::edam::NoteStoreClient *m_client;
+
+    QHash<QString, Notebook*> m_notebooks;
+    QHash<QString, Note*> m_notes;
+
+    QList<EvernoteJob*> m_jobQueue;
+    QThread *m_currentJob;
 };
 
 #endif // NOTESSTORE_H
 
=== modified file 'src/plugin/Evernote/userstore.h'
--- src/plugin/Evernote/userstore.h	2013-11-21 23:30:15 +0000
+++ src/plugin/Evernote/userstore.h	2013-11-25 00:51:38 +0000
@@ -5,8 +5,6 @@
 
 #include <QObject>
 
-using namespace evernote::edam;
-
 class UserStore : public QObject
 {
     Q_OBJECT