Merge lp:~mzanetti/reminders-app/notes-refactor into lp:reminders-app

[Michael Zanetti]

Add proper Notes classes and refactor server interaction and error handling

This adds proper classes for Notes and Notebooks to be used with QML. Also, it refactors the interaction to evernote to be threaded in order to not block the ui. Last but not least it removes the ugly displayException() method from the NotesStore and uses proper error handling instead. We still need to communicate error to the UI somehow.

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

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

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

review: Needs Fixing (continuous-integration)

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

PASSED: Continuous integration, rev:11
http://91.189.93.70:8080/job/reminders-app-ci/20/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/288
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/20
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/20
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/20

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

review: Approve (continuous-integration)

[David Planella (dpm)]

Looks good to me and works well, nice to see the improvement in UI responsiveness.

review: Approve

=== 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-24 20:43:59 +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-24 20:43:59 +0000
@@ -3,13 +3,14 @@
 import Evernote 0.1
 
 Page {
-
-    property alias text: noteTextArea.text
+    title: note.title
+    property var note
 
     TextArea {
         id: noteTextArea
         anchors.fill: parent
         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-24 20:43:59 +0000
@@ -8,16 +8,8 @@
 
     property alias filter: notes.filterNotebookGuid
 
-    onActiveChanged: {
-        if (active) {
-            notes.refresh();
-        }
-    }
-
     Notes {
         id: notes
-
-        onFilterNotebookGuidChanged: refresh();
     }
 
     ListView {
@@ -28,7 +20,7 @@
             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)})
             }
         }
     }

=== 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-24 20:43:59 +0000
@@ -13,13 +13,23 @@
     notesstore.cpp \
     userstore.cpp \
     notebooks.cpp \
-    notes.cpp
+    notes.cpp \
+    note.cpp \
+    notebook.cpp \
+    fetchnotesjob.cpp \
+    fetchnotebooksjob.cpp \
+    fetchnotejob.cpp
 
 HEADERS += evernoteplugin.h \
     notesstore.h \
     userstore.h \
     notebooks.h \
-    notes.h
+    notes.h \
+    note.h \
+    notebook.h \
+    fetchnotesjob.h \
+    fetchnotebooksjob.h \
+    fetchnotejob.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-24 20:43:59 +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 file 'src/plugin/Evernote/fetchnotebooksjob.cpp'
--- src/plugin/Evernote/fetchnotebooksjob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/fetchnotebooksjob.cpp	2013-11-24 20:43:59 +0000
@@ -0,0 +1,25 @@
+#include "fetchnotebooksjob.h"
+
+#include <QDebug>
+
+FetchNotebooksJob::FetchNotebooksJob(evernote::edam::NoteStoreClient *client, const QString &token, QObject *parent) :
+    QThread(parent),
+    m_client(client),
+    m_token(token)
+{
+}
+
+
+void FetchNotebooksJob::run()
+{
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+    std::vector<evernote::edam::Notebook> results;
+    try {
+        m_client->listNotebooks(results, m_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/fetchnotebooksjob.h'
--- src/plugin/Evernote/fetchnotebooksjob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/fetchnotebooksjob.h	2013-11-24 20:43:59 +0000
@@ -0,0 +1,29 @@
+#ifndef FETCHNOTEBOOKSJOB_H
+#define FETCHNOTEBOOKSJOB_H
+
+#include "notesstore.h"
+
+// Evernote SDK
+#include <NoteStore.h>
+#include <NoteStore_constants.h>
+#include <Errors_types.h>
+
+#include <QThread>
+
+class FetchNotebooksJob : public QThread
+{
+    Q_OBJECT
+public:
+    explicit FetchNotebooksJob(evernote::edam::NoteStoreClient *client, const QString &token, QObject *parent = 0);
+
+    void run();
+
+signals:
+    void resultReady(NotesStore::ErrorCode errorCode, const std::vector<evernote::edam::Notebook> &results);
+
+private:
+    evernote::edam::NoteStoreClient *m_client;
+    QString m_token;
+};
+
+#endif // FETCHNOTEBOOKSJOB_H

=== added file 'src/plugin/Evernote/fetchnotejob.cpp'
--- src/plugin/Evernote/fetchnotejob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/fetchnotejob.cpp	2013-11-24 20:43:59 +0000
@@ -0,0 +1,26 @@
+#include "fetchnotejob.h"
+
+FetchNoteJob::FetchNoteJob(evernote::edam::NoteStoreClient *client, const QString &token, const QString &guid, QObject *parent) :
+    QThread(parent),
+    m_client(client),
+    m_token(token),
+    m_guid(guid)
+{
+}
+
+void FetchNoteJob::run()
+{
+    NotesStore::ErrorCode errorCode = NotesStore::ErrorCodeNoError;
+    evernote::edam::Note result;
+    try {
+        m_client->getNote(result, m_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;
+    }
+
+    emit resultReady(errorCode, result);
+}

=== added file 'src/plugin/Evernote/fetchnotejob.h'
--- src/plugin/Evernote/fetchnotejob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/fetchnotejob.h	2013-11-24 20:43:59 +0000
@@ -0,0 +1,29 @@
+#ifndef FETCHNOTEJOB_H
+#define FETCHNOTEJOB_H
+
+#include "notesstore.h"
+
+// Evernote SDK
+#include <NoteStore.h>
+#include <NoteStore_constants.h>
+#include <Errors_types.h>
+
+#include <QThread>
+
+class FetchNoteJob : public QThread
+{
+    Q_OBJECT
+public:
+    explicit FetchNoteJob(evernote::edam::NoteStoreClient *client, const QString &token, 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/fetchnotesjob.cpp'
--- src/plugin/Evernote/fetchnotesjob.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/fetchnotesjob.cpp	2013-11-24 20:43:59 +0000
@@ -0,0 +1,48 @@
+#include "fetchnotesjob.h"
+
+#include "notesstore.h"
+
+#include <QDebug>
+
+FetchNotesJob::FetchNotesJob(evernote::edam::NoteStoreClient *client,
+                             const QString &token,
+                             const QString &filterNotebookGuid, QObject *parent) :
+    QThread(parent),
+    m_client(client),
+    m_token(token),
+    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 {
+        m_client->findNotesMetadata(results, m_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/fetchnotesjob.h'
--- src/plugin/Evernote/fetchnotesjob.h	1970-01-01 00:00:00 +0000
+++ src/plugin/Evernote/fetchnotesjob.h	2013-11-24 20:43:59 +0000
@@ -0,0 +1,30 @@
+#ifndef FETCHNOTESJOB_H
+#define FETCHNOTESJOB_H
+
+#include "notesstore.h"
+
+// Evernote SDK
+#include <NoteStore.h>
+#include <NoteStore_constants.h>
+#include <Errors_types.h>
+
+#include <QThread>
+
+class FetchNotesJob : public QThread
+{
+    Q_OBJECT
+public:
+    explicit FetchNotesJob(evernote::edam::NoteStoreClient *client, const QString &token, const QString &filterNotebookGuid, QObject *parent = 0);
+
+    void run();
+
+signals:
+    void resultReady(NotesStore::ErrorCode errorCode, const evernote::edam::NotesMetadataList &results);
+
+private:
+    evernote::edam::NoteStoreClient *m_client;
+    QString m_token;
+    QString m_filterNotebookGuid;
+};
+
+#endif // FETCHNOTESJOB_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-24 20:43:59 +0000
@@ -0,0 +1,51 @@
+#include "note.h"
+
+Note::Note(const QString &guid, QObject *parent) :
+    QObject(parent),
+    m_guid(guid)
+{
+}
+
+QString Note::guid() const
+{
+    return m_guid;
+}
+
+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();
+    }
+}

=== 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-24 20:43:59 +0000
@@ -0,0 +1,40 @@
+#ifndef NOTE_H
+#define NOTE_H
+
+#include <QObject>
+
+class Note : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString guid READ guid CONSTANT)
+    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, QObject *parent = 0);
+
+    QString guid() const;
+
+    QString notebookGuid() const;
+    void setNotebookGuid(const QString &notebookGuid);
+
+    QString title() const;
+    void setTitle(const QString &title);
+
+    QString content() const;
+    void setContent(const QString &content);
+
+signals:
+    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-24 20:43:59 +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-24 20:43:59 +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-24 20:43:59 +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,13 @@
 
 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);
-//    }
+    qDebug() << "refreshing notebooks";
+    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-24 20:43:59 +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-24 20:43:59 +0000
@@ -1,19 +1,22 @@
 #include "notes.h"
+#include "note.h"
 
 #include <QDebug>
 
 Notes::Notes(QObject *parent) :
     QAbstractListModel(parent)
 {
+    connect(NotesStore::instance(), SIGNAL(noteAdded(const QString &)), SLOT(noteAdded(const QString &)));
 }
 
 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 +48,40 @@
     }
 }
 
-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));
+    }
 }

=== 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-24 20:43:59 +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,23 @@
     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);
+
 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-24 20:43:59 +0000
@@ -1,6 +1,11 @@
 #include "notesstore.h"
-
 #include "notebooks.h"
+#include "notebook.h"
+#include "note.h"
+
+#include "fetchnotesjob.h"
+#include "fetchnotebooksjob.h"
+#include "fetchnotejob.h"
 
 // Thrift
 #include <arpa/inet.h> // seems thrift forgot this one
@@ -11,7 +16,6 @@
 
 #include <QDebug>
 
-using namespace evernote::edam;
 using namespace apache::thrift;
 using namespace apache::thrift::protocol;
 using namespace apache::thrift::transport;
@@ -19,11 +23,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 +57,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 +82,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 +110,159 @@
 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);
+}
+
+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_requestQueue.isEmpty()) {
+        return;
+    }
+
+    if (m_currentJob) {
+        return;
+    }
+    m_currentJob = m_requestQueue.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(m_client, m_token, filterNotebookGuid);
+    connect(job, &FetchNotesJob::resultReady, this, &NotesStore::fetchNotesJobDone);
+    connect(job, &FetchNoteJob::finished, job, &FetchNotesJob::deleteLater);
+
+    m_requestQueue.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) {
+            qDebug() << "Received update for existing note";
+        } 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(m_client, m_token, guid, this);
+    connect(job, &FetchNoteJob::resultReady, this, &NotesStore::fetchNoteJobDone);
+    connect(job, &FetchNoteJob::finished, job, &FetchNoteJob::deleteLater);
+    m_requestQueue.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(m_client, m_token);
+    connect(job, &FetchNotebooksJob::resultReady, this, &NotesStore::fetchNotebooksJobDone);
+    connect(job, &FetchNotebooksJob::finished, job, &FetchNotebooksJob::deleteLater);
+
+    m_requestQueue.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";
+        } 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());
+        }
+    }
+
+    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-24 20:43:59 +0000
@@ -6,12 +6,11 @@
 #include <NoteStore_constants.h>
 #include <Errors_types.h>
 
-// Qt
 #include <QObject>
-
-using namespace evernote::edam;
-
-class Notebooks;
+#include <QHash>
+
+class Notebook;
+class Note;
 
 class NotesStore : public QObject
 {
@@ -19,29 +18,59 @@
     Q_PROPERTY(QString token READ token WRITE setToken NOTIFY tokenChanged)
 
 public:
+    enum ErrorCode {
+        ErrorCodeNoError,
+        ErrorCodeUserException,
+        ErrorCodeSystemException,
+        ErrorCodeNotFoundExcpetion
+    };
+
     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);
+
+    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 notebookAdded(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 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<QThread*> m_requestQueue;
+    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-24 20:43:59 +0000
@@ -5,8 +5,6 @@
 
 #include <QObject>
 
-using namespace evernote::edam;
-
 class UserStore : public QObject
 {
     Q_OBJECT