//*******************************************************
//* The current text has changed
//*******************************************************
void TagEditorNewTag::textModified(QString text) {
QLOG_TRACE_IN() << typeid(*this).name();
if (this->hasFocus()) {
QLOG_TRACE_OUT() << typeid(*this).name();
return;
}
this->blockSignals(true);
setText(text);
this->blockSignals(false);
QLOG_TRACE_OUT() << typeid(*this).name();
}
//*******************************************************
//* Reset the tag editor to the default text
//*******************************************************
void TagEditorNewTag::resetText() {
QLOG_TRACE_IN() << typeid(*this).name();
blockSignals(true);
setText("");
blockSignals(false);
QLOG_TRACE_OUT() << typeid(*this).name();
}
//****************************************************
//* Constructor
//****************************************************
TagEditorNewTag::TagEditorNewTag(QWidget *parent) :
QLineEdit(parent)
{
QLOG_TRACE_IN() << typeid(*this).name();
account = 0;
this->setCursor(Qt::PointingHandCursor);
// Setup the note title editor
QPalette pal;
pal.setColor(backgroundRole(), QPalette::Base);
setPalette(pal);
this->setFont(global.getGuiFont(font()));
inactiveColor = "QLineEdit {background-color: transparent; border-radius: 0px;} ";
activeColor = "QLineEdit {border: 1px solid #808080; background-color: white; border-radius: 4px;} ";
this->setStyleSheet(inactiveColor);
this->setPlaceholderText(tr("Click to add tag..."));
connect(this, SIGNAL(textChanged(QString)), this, SLOT(textModified(QString)));
// connect(this, SIGNAL(focussed(bool)), this, SLOT(gainedFocus(bool)));
completer = new QCompleter(this);
connect(completer, SIGNAL(activated(QString)), this, SLOT(mouseCompleterSelection(QString)));
loadCompleter();
connect(this, SIGNAL(returnPressed()), this, SLOT(enterPressed()));
hide();
QLOG_TRACE_OUT() << typeid(*this).name();
}
//***********************************************************
//* Load the completer with the list of valid tag names
//***********************************************************
void TagEditorNewTag::loadCompleter() {
QLOG_TRACE_IN() << typeid(*this).name();
QList<int> tagList;
TagTable tagTable(global.db);
QStringList tagNames;
tagTable.getAll(tagList);
for (qint32 i=0; i<tagList.size(); i++) {
Tag t;
QString guid;
tagTable.getGuid(guid, tagList[i]);
tagTable.get(t, guid);
QString name = t.name;
qint32 tagAccount = tagTable.owningAccount(tagList[i]);
if (!currentTags.contains(name) && tagAccount == account)
tagNames << name;
}
qSort(tagNames.begin(), tagNames.end(), caseInsensitiveLessThan);
completer->setModelSorting(QCompleter::CaseInsensitivelySortedModel);
completer->setCaseSensitivity(Qt::CaseInsensitive);
setCompleter(completer);
QStringListModel *model;
model = (QStringListModel*)(completer->model());
if(model==NULL)
model = new QStringListModel();
model->setStringList(tagNames);
completer->setModel(model);
QLOG_TRACE_OUT() << typeid(*this).name();
}
// Upload any saved searchs
qint32 SyncRunner::uploadSavedSearches() {
QLOG_TRACE_IN();
qint32 usn;
qint32 maxUsn = 0;
SearchTable stable(db);
QList<qint32> lids;
stable.getAllDirty(lids);
if (lids.size() == 0) {
QLOG_TRACE_OUT();
return 0;
}
for (int i = 0; i < lids.size(); i++) {
SavedSearch search;
stable.get(search, lids[i]);
if (!stable.isDeleted(lids[i])) {
qint32 oldUsn = search.updateSequenceNum;
usn = comm->uploadSavedSearch(search);
if (usn == 0) {
this->communicationErrorHandler();
error = true;
QLOG_TRACE_OUT();
return maxUsn;
}
if (usn > maxUsn) {
maxUsn = usn;
if (oldUsn == 0)
stable.updateGuid(lids[i], search.guid);
stable.setUpdateSequenceNumber(lids[i], usn);
} else {
error = true;
}
} else {
QString guid = stable.getGuid(lids[i]);
stable.expunge(lids[i]);
if (search.updateSequenceNum > 0) {
usn = comm->expungeSavedSearch(guid);
if (usn > maxUsn)
maxUsn = usn;
}
}
}
QLOG_TRACE_OUT();
return maxUsn;
}
//*******************************************************
//* Focus event. The editor has lost focus
//*******************************************************
void TagEditorNewTag::focusOutEvent(QFocusEvent *e)
{
QLOG_TRACE_IN() << typeid(*this).name();
this->setCursor(Qt::PointingHandCursor);
QLineEdit::focusOutEvent(e);
setStyleSheet(inactiveColor);
emit(focussed(false));
QLOG_TRACE_OUT() << typeid(*this).name();
}
//*******************************************************
//* Override the event loop. If the user presses "TAB"
//* and there is a valid tag entered, we signal the parent
//* that a new tag is needed.
//*******************************************************
bool TagEditorNewTag::event(QEvent *event)
{
QLOG_TRACE_IN() << typeid(*this).name();
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = (QKeyEvent*)event;
if (ke->key() == Qt::Key_Tab) {
if (getText().trimmed() != "") {
emit(tabPressed());
QLOG_TRACE_OUT() << typeid(*this).name();
return true;
}
QLOG_TRACE_OUT() << typeid(*this).name();
return QLineEdit::event(event);
}
}
QLOG_TRACE_OUT() << typeid(*this).name();
return QLineEdit::event(event);
}
//*******************************************************
//* Focus event. The editor has gained focus
//*******************************************************
void TagEditorNewTag::focusInEvent(QFocusEvent *e)
{
QLOG_TRACE_IN() << typeid(*this).name();
this->setCursor(Qt::ArrowCursor);
QLineEdit::focusInEvent(e);
setStyleSheet(activeColor);
emit(focussed(true));
QLOG_TRACE_OUT() << typeid(*this).name();
}
// Upload any saved searchs
qint32 SyncRunner::uploadNotebooks() {
QLOG_TRACE_IN();
qint32 usn;
qint32 maxUsn = 0;
NotebookTable table(db);
QList<qint32> lids;
table.resetDirtyLocalNotebooks();
table.resetLinkedNotebooksDirty();
table.getAllDirty(lids);
for (int i = 0; i < lids.size(); i++) {
Notebook notebook;
table.get(notebook, lids[i]);
if (!table.isDeleted(lids[i])) {
qint32 oldUsn = notebook.updateSequenceNum;
usn = comm->uploadNotebook(notebook);
if (usn == 0) {
this->communicationErrorHandler();
error = true;
QLOG_TRACE_OUT();
return maxUsn;
}
if (usn > maxUsn) {
maxUsn = usn;
if (oldUsn == 0)
table.updateGuid(lids[i], notebook.guid);
table.setUpdateSequenceNumber(lids[i], usn);
} else {
error = true;
}
} else {
QString guid;
table.getGuid(guid, lids[i]);
table.expunge(lids[i]);
if (notebook.updateSequenceNum > 0) {
usn = comm->expungeNotebook(guid);
if (usn > maxUsn)
maxUsn = usn;
}
}
}
QLOG_TRACE_OUT();
return maxUsn;
}
// Synchronize remote linked notebooks
void SyncRunner::syncRemoteLinkedNotebooksChunk(QList<LinkedNotebook> books) {
QLOG_TRACE_IN();
LinkedNotebookTable ltable(db);
for (int i = 0; i < books.size(); i++) {
qint32 lid = ltable.sync(books[i]);
LinkedNotebook lbk = books[i];
QString sharename = "";
QString username = "";
if (lbk.shareName.isSet())
sharename = lbk.shareName;
if (lbk.username.isSet())
username = lbk.username;
if (!finalSync)
emit notebookUpdated(lid, sharename, username, true, false);
}
QLOG_TRACE_OUT();
}
bool SyncRunner::syncRemoteToLocal(qint32 updateCount) {
QLOG_TRACE_IN();
// The sync is run in several parts.
// Part #1: Get all remote tags, notebooks, & saved searches for
// a user's account. We do this first because we want
// the tag & notebook naems for filling out the note table.
// It is just easier this way.
// Part #2: Get all changed notes & resources. If it is a full sync
// then we get the resources & notes together as one entity
// (the resource chunk won't have anything). We also do not
// get deleted notes on a full sync. If it is a partial sync
// then we get resources & notes separately (i.e. the notes chunk
// may reference a resource guid, but it won't have the detail and
// the chunk resources will have valid data. We get deleted notes
// on a partial sync.
// Part #3: Upload anything local to the user's account.
// Part #4: Do linked notebook stuff. Basically the same as
// this except we do it across multiple accounts.
int chunkSize = 5000;
bool more = true;
bool rc;
int startingSequenceNumber = updateSequenceNumber;
while (more && keepRunning) {
SyncChunk chunk;
rc = comm->getSyncChunk(chunk, updateSequenceNumber, chunkSize,
SYNC_CHUNK_LINKED_NOTEBOOKS | SYNC_CHUNK_NOTEBOOKS |
SYNC_CHUNK_TAGS | SYNC_CHUNK_SEARCHES | SYNC_CHUNK_EXPUNGED,
fullSync);
if (!rc) {
QLOG_ERROR() << "Error retrieving chunk";
error = true;
this->communicationErrorHandler();
QLOG_TRACE_OUT();
return false;
}
QLOG_DEBUG() << "-(Pass 1)->>>> Old USN:" << updateSequenceNumber << " New USN:" << chunk.chunkHighUSN;
int pct = (updateSequenceNumber - startingSequenceNumber) * 100 / (updateCount - startingSequenceNumber);
emit setMessage(tr("Download ") + QString::number(pct) + tr("% complete for notebooks, tags, & searches."),
defaultMsgTimeout);
processSyncChunk(chunk);
updateSequenceNumber = chunk.chunkHighUSN;
if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount)
more = false;
}
emit setMessage(tr("Download complete for notebooks, tags, & searches. Downloading notes."), defaultMsgTimeout);
comm->loadTagGuidMap();
more = true;
chunkSize = 50;
updateSequenceNumber = startingSequenceNumber;
UserTable userTable(db);
while (more && keepRunning) {
SyncChunk chunk;
rc = comm->getSyncChunk(chunk, updateSequenceNumber, chunkSize, SYNC_CHUNK_NOTES | SYNC_CHUNK_RESOURCES,
fullSync);
if (!rc) {
QLOG_ERROR() << "Error retrieving chunk";
error = true;
this->communicationErrorHandler();
QLOG_TRACE_OUT();
return false;
}
QLOG_DEBUG() << "-(Pass 2) ->>>> Old USN:" << updateSequenceNumber << " New USN:" << chunk.chunkHighUSN;
int pct = (updateSequenceNumber - startingSequenceNumber) * 100 / (updateCount - startingSequenceNumber);
emit setMessage(tr("Download ") + QString::number(pct) + tr("% complete."), defaultMsgTimeout);
processSyncChunk(chunk);
userTable.updateLastSyncNumber(chunk.chunkHighUSN);
userTable.updateLastSyncDate(chunk.currentTime);
updateSequenceNumber = chunk.chunkHighUSN;
if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount) {
more = false;
userTable.updateLastSyncNumber(updateCount);
}
}
emit setMessage(tr("Download complete."), defaultMsgTimeout);
QLOG_TRACE_OUT();
return true;
}
void TagEditorNewTag::notebookSelectionChanged(qint32 notebook) {
QLOG_TRACE_IN() << typeid(*this).name();
account = notebook;
loadCompleter();
QLOG_TRACE_OUT() << typeid(*this).name();
}
//*******************************************************
//* Add a new tag to the completer list
//*******************************************************
void TagEditorNewTag::addTag(QString s) {
QLOG_TRACE_IN() << typeid(*this).name();
currentTags.append(s);
loadCompleter();
QLOG_TRACE_OUT() << typeid(*this).name();
}
//*******************************************************
//* Set the list of valid tags for the completer
//*******************************************************
void TagEditorNewTag::setTags(QStringList s) {
QLOG_TRACE_IN() << typeid(*this).name();
currentTags = s;
loadCompleter();
QLOG_TRACE_OUT() << typeid(*this).name();
}
//*******************************************************
//* Get the current text. If the text is the default
//* text, the n return an empty string.
//*******************************************************
QString TagEditorNewTag::getText() {
QLOG_TRACE_IN() << typeid(*this).name();
QString retval = text().trimmed();
QLOG_TRACE_OUT() << typeid(*this).name();
return retval;
}
// Synchronize remote linked notebooks
bool SyncRunner::syncRemoteLinkedNotebooksActual() {
QLOG_TRACE_IN();
LinkedNotebookTable ltable(db);
QList<qint32> lids;
ltable.getAll(lids);
bool fs;
for (int i = 0; i < lids.size(); i++) {
LinkedNotebook book;
qint32 usn = ltable.getLastUpdateSequenceNumber(lids[i]);
qint32 startingUSN = usn;
ltable.get(book, lids[i]);
int chunkSize = 5000;
// If the share key is set, we need to authenticate
if (!comm->authenticateToLinkedNotebookShard(book)) {
// If we can't authenticate, we just gid of the notebook
// because the user probably stopped sharing.
qint32 linkedLid = 0;
LinkedNotebookTable ntable(db);
linkedLid = ntable.getLid(book.guid);
ntable.expunge(book.guid);
emit notebookExpunged(linkedLid);
return true;
//this->communicationErrorHandler();
//error = true;
//return false;
}
bool more = true;
SyncState syncState;
if (!comm->getLinkedNotebookSyncState(syncState, book)) {
this->communicationErrorHandler();
error = true;
return false;
}
if (syncState.updateCount <= usn)
more = false;
qint32 startingSequenceNumber = usn;
if (usn == 0)
fs = true;
else
fs = false;
// ***** STARTING PASS #1
while (more && keepRunning) {
SyncChunk chunk;
if (!comm->getLinkedNotebookSyncChunk(chunk, book, usn, chunkSize, fs)) {
more = false;
if (comm->getLastErrorType() == CommunicationError::EDAMNotFoundException) {
ltable.expunge(lids[i]);
if (!finalSync)
emit(notebookExpunged(lids[i]));
} else {
this->communicationErrorHandler();
error = true;
QLOG_TRACE_OUT();
return false;
}
} else {
processSyncChunk(chunk, lids[i]);
usn = chunk.chunkHighUSN;
if (chunk.updateCount > 0 && chunk.updateCount > startingSequenceNumber) {
int pct = (usn - startingSequenceNumber) * 100 / (chunk.updateCount - startingSequenceNumber);
QString sharename = "";
if (book.shareName.isSet())
sharename = book.shareName;
emit setMessage(
tr("Downloading ") + QString::number(pct) + tr("% complete for tags in shared notebook ") +
sharename + tr("."), defaultMsgTimeout);
}
if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount)
more = false;
}
}
//************* STARTING PASS 2
usn = startingUSN;
more = true;
chunkSize = 50;
if (error == true)
more = false;
QString sharename = "";
if (book.shareName.isSet())
sharename = book.shareName;
emit setMessage(tr("Downloading notes for shared notebook ") + sharename + tr("."), defaultMsgTimeout);
while (more && keepRunning) {
SyncChunk chunk;
if (!comm->getLinkedNotebookSyncChunk(chunk, book, usn, chunkSize, fs)) {
more = false;
if (comm->getLastErrorType()== CommunicationError::EDAMNotFoundException) {
ltable.expunge(lids[i]);
if (!finalSync)
emit(notebookExpunged(lids[i]));
} else {
this->communicationErrorHandler();
error = true;
return false;
}
} else {
processSyncChunk(chunk, lids[i]);
usn = chunk.chunkHighUSN;
if (chunk.updateCount > 0 && chunk.updateCount > startingSequenceNumber) {
int pct = (usn - startingSequenceNumber) * 100 / (chunk.updateCount - startingSequenceNumber);
QString sharename = "";
if (book.shareName.isSet())
sharename = book.shareName;
emit setMessage(
tr("Downloading ") + QString::number(pct) + tr("% complete for shared notebook ") + sharename +
tr("."), defaultMsgTimeout);
}
if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount) {
more = false;
ltable.setLastUpdateSequenceNumber(lids[i], syncState.updateCount);
}
}
}
qint32 noteUSN = uploadLinkedNotes(lids[i]);
if (noteUSN > usn)
ltable.setLastUpdateSequenceNumber(lids[i], noteUSN);
}
TagTable tagTable(db);
tagTable.cleanupLinkedTags();
QLOG_TRACE_OUT();
return true;
}
// Upload notes that belong to me
qint32 SyncRunner::uploadPersonalNotes() {
QLOG_TRACE_IN();
qint32 usn;
qint32 maxUsn = 0;
NotebookTable notebookTable(db);
LinkedNotebookTable linkedNotebookTable(db);
NoteTable noteTable(db);
QList<qint32> lids, validLids, deletedLids, movedLids;
QStringList deleteQueueGuids;
noteTable.getAllDirty(lids);
// Get all of the notes that were deleted, and then removed from the trash
noteTable.getAllDeleteQueue(deleteQueueGuids);
// Get a list of all notes that are both dirty and in an account we own and isn't deleted
for (int i = 0; i < lids.size(); i++) {
qint32 notebookLid = noteTable.getNotebookLid(lids[i]);
if (!linkedNotebookTable.exists(notebookLid)) {
if (!notebookTable.isLocal(notebookLid)) {
if (noteTable.isDeleted(lids[i]))
deletedLids.append(lids[i]);
else
validLids.append(lids[i]);
} else {
// We have a note that is local. Check if it was once
// synchronized. If so, it was moved to a local notebook
// and now needs to be deleted on the remote end
Note n;
noteTable.get(n, lids[i], false, false);
if (n.updateSequenceNum.isSet() && n.updateSequenceNum > 0) {
movedLids.append(lids[i]);
}
}
}
}
// Start deleting notes
for (int i = 0; i < deletedLids.size(); i++) {
QString guid = noteTable.getGuid(deletedLids[i]);
noteTable.setDirty(lids[i], false);
usn = comm->deleteNote(guid);
if (usn > maxUsn) {
maxUsn = usn;
noteTable.setUpdateSequenceNumber(deletedLids[i], usn);
noteTable.setDirty(deletedLids[i], false);
if (!finalSync)
emit(noteSynchronized(deletedLids[i], false));
}
}
// Start handling notes moved to a local notebook. What
// we do is to delete the note on Evernote, then give the
// note in the local notebook a new GUID & set the
// update sequence number to 0.
for (int i = 0; i < movedLids.size(); i++) {
QUuid uuid;
Guid newGuid = uuid.createUuid().toString().replace("{", "").replace("}", "");
QString guid = noteTable.getGuid(movedLids[i]);
noteTable.setDirty(movedLids[i], false);
noteTable.updateGuid(movedLids[i], newGuid);
noteTable.setUpdateSequenceNumber(movedLids[0], 0);
usn = comm->deleteNote(guid);
if (usn > maxUsn) {
maxUsn = usn;
}
if (!finalSync)
emit(noteSynchronized(movedLids[i], false));
}
// Delete any notes that were deleted, but emptied from the trash
for (int i = 0; i < deleteQueueGuids.size(); i++) {
QString guid = deleteQueueGuids[i];
usn = comm->deleteNote(guid);
if (usn > maxUsn) {
maxUsn = usn;
}
noteTable.expungeFromDeleteQueue(guid);
}
// Start uploading notes
for (int i = 0; i < validLids.size(); i++) {
Note note;
noteTable.get(note, validLids[i], true, true);
qint32 oldUsn = 0;
if (note.updateSequenceNum.isSet())
oldUsn = note.updateSequenceNum;
usn = comm->uploadNote(note);
if (usn == 0) {
this->communicationErrorHandler();
if (note.title.isSet())
QLOG_ERROR() << tr("Error uploading note:") + note.title;
else QLOG_ERROR() << tr("Error uploading note with a missing title!");
error = true;
//return maxUsn;
}
if (usn > maxUsn) {
maxUsn = usn;
if (oldUsn == 0)
noteTable.updateGuid(validLids[i], note.guid);
noteTable.setUpdateSequenceNumber(validLids[i], usn);
noteTable.setDirty(validLids[i], false);
if (!finalSync)
emit(noteSynchronized(validLids[i], false));
} else {
error = true;
}
}
QLOG_TRACE_OUT();
return maxUsn;
}
//******************************************************
//* Set the color whe the editor has a good focus
//******************************************************
void TagEditorNewTag::setActiveColor() {
QLOG_TRACE_IN() << typeid(*this).name();
setStyleSheet(activeColor);
QLOG_TRACE_OUT() << typeid(*this).name();
}
// Upload any tags
qint32 SyncRunner::uploadTags() {
QLOG_TRACE_IN();
qint32 usn;
qint32 maxUsn = 0;
TagTable table(db);
QList<qint32> lids, deletedLids, updatedLids;
table.resetLinkedTagsDirty();
table.getAllDirty(lids);
if (lids.size() == 0) {
QLOG_TRACE_OUT();
return 0;
}
// Split the lids into lids to be updated, and lids to be deleted
for (int i = 0; i < lids.size(); i++) {
if (table.isDeleted(lids[i]))
deletedLids.append(lids[i]);
else
updatedLids.append(lids[i]);
}
// Get existing tags in case there is a duplicate name
QList<Tag> existingTags;
comm->getTagList(existingTags);
// Update any lids
QLOG_DEBUG() << "Beginning to upload new & altered tags";
int i = 0;
while (updatedLids.size() > 0) {
Tag tag;
table.get(tag, updatedLids[i]);
if (tag.name.isSet()) {
QLOG_DEBUG() << "Found changed tag " << tag.name;
}
qint32 parentLid = 0;
QString parentGuid = "";
if (tag.parentGuid.isSet())
parentGuid = tag.parentGuid;
if (parentGuid != "")
parentLid = table.getLid(tag.parentGuid);
// If the parent is either not dirty, or there is no parent we can update this lid.
if (parentLid <= 0 || !table.isDirty(parentLid)) {
QLOG_DEBUG() << "Tag has no parent or parent is unaltered";
// Check if a tag with this name already exists.
// In reality this should never happen, but there was a bug
// where a tag was uploaded but the USN & GUID wasn't
// updated. This is a workaround for people who
// have that bug.
Tag foundTag;
bool matchFound = false;
for (int j = 0; j < existingTags.size(); j++) {
QString tempTagName = existingTags[j].name;
if (tempTagName == tag.name) {
matchFound = true;
foundTag = existingTags[j];
j = existingTags.size();
}
}
if (!matchFound) {
qint32 oldUsn = 0;
if (tag.updateSequenceNum.isSet())
oldUsn = tag.updateSequenceNum;
QLOG_DEBUG() << "Uploaing tag " << tag.name;
usn = comm->uploadTag(tag);
if (usn == 0) {
this->communicationErrorHandler();
error = true;
QLOG_TRACE_OUT();
return maxUsn;
}
if (usn > 0) {
maxUsn = usn;
QLOG_DEBUG() << "Tag USN: " << usn;
if (oldUsn == 0) {
QLOG_DEBUG() << "New USN: " << tag.guid;
table.updateGuid(updatedLids[i], tag.guid);
}
table.setUpdateSequenceNumber(updatedLids[i], usn);
table.setDirty(tag.guid, false);
updatedLids.removeAt(i);
i = -1; // Reset for the next time through the loop
} else {
error = true;
updatedLids.clear();
}
} else {
QLOG_DEBUG() << "Tag with this name exists.";
table.updateGuid(updatedLids[i], foundTag.guid);
table.setUpdateSequenceNumber(updatedLids[i], foundTag.updateSequenceNum);
updatedLids.removeAt(i);
i = -1; // Reset for the next time through the loop
}
}
i++;
}
QLOG_DEBUG() << "Deleting LIDS";
// delete any lids
for (int i = 0; i < deletedLids.size(); i++) {
Tag tag;
table.get(tag, deletedLids[i]);
table.expunge(lids[i]);
if (tag.updateSequenceNum > 0) {
usn = comm->expungeTag(tag.guid);
if (usn > maxUsn)
maxUsn = usn;
}
}
QLOG_TRACE_OUT();
return maxUsn;
}
// Upload notes that belong to me
qint32 SyncRunner::uploadLinkedNotes(qint32 notebookLid) {
QLOG_TRACE_IN();
qint32 usn;
qint32 maxUsn = 0;
NoteTable noteTable(db);
QList<qint32> lids, validLids, deletedLids;
noteTable.getAllDirty(lids, notebookLid);
// Split the list into deleted and updated notes
for (int i = 0; i < lids.size(); i++) {
if (noteTable.isDeleted(lids[i]))
deletedLids.append(lids[i]);
else
validLids.append(lids[i]);
}
// Start deleting notes
for (int i = 0; i < deletedLids.size(); i++) {
QString guid = noteTable.getGuid(deletedLids[i]);
noteTable.setDirty(lids[i], false);
usn = comm->deleteLinkedNote(guid);
if (usn > maxUsn) {
maxUsn = usn;
noteTable.setUpdateSequenceNumber(deletedLids[i], usn);
noteTable.setDirty(deletedLids[i], false);
if (!finalSync)
emit(noteSynchronized(deletedLids[i], false));
}
}
// Start deleting notes that were in the trash, but the trash was
// emptied.
NotebookTable bookTable(db);
QString notebookGuid = "";
bookTable.getGuid(notebookGuid, notebookLid);
// Get all of the notes
QStringList deleteQueueGuids;
noteTable.getAllDeleteQueue(deleteQueueGuids, notebookGuid);
// Do the actual deletes
for (int i = 0; i < deleteQueueGuids.size(); i++) {
QString guid = deleteQueueGuids[i];
usn = comm->deleteLinkedNote(guid);
if (usn > maxUsn) {
maxUsn = usn;
}
noteTable.expungeFromDeleteQueue(guid);
}
// Start uploading notes
for (int i = 0; i < validLids.size(); i++) {
Note note;
noteTable.get(note, validLids[i], true, true);
qint32 oldUsn = note.updateSequenceNum;
usn = comm->uploadLinkedNote(note);
if (usn == 0) {
this->communicationErrorHandler();
error = true;
QLOG_TRACE_OUT();
return maxUsn;
}
if (usn > maxUsn) {
maxUsn = usn;
if (oldUsn == 0)
noteTable.updateGuid(validLids[i], note.guid);
noteTable.setUpdateSequenceNumber(validLids[i], usn);
noteTable.setDirty(validLids[i], false);
if (!finalSync)
emit(noteSynchronized(validLids[i], false));
} else {
error = true;
}
}
QLOG_TRACE_OUT();
return maxUsn;
}
