/*\r
- * This file is part of NeverNote \r
+ * This file is part of NixNote \r
* Copyright 2009 Randy Baumgarte\r
* \r
* This file may be licensed under the terms of of the\r
import com.trolltech.qt.core.QFile;\r
import com.trolltech.qt.core.QIODevice.OpenModeFlag;\r
import com.trolltech.qt.core.QObject;\r
+import com.trolltech.qt.core.QTextCodec;\r
import com.trolltech.qt.gui.QMessageBox;\r
\r
import cx.fbn.nevernote.signals.NoteIndexSignal;\r
private DatabaseConnection conn;\r
private boolean idle;\r
public boolean error;\r
+ public volatile Vector<String> errorSharedNotebooks;\r
+ public volatile HashMap<String,String> errorSharedNotebooksIgnored;\r
public volatile boolean isConnected;\r
public volatile boolean keepRunning;\r
public volatile String authToken;\r
private long evernoteUpdateCount;\r
- private final String userAgent = "NeverNote/" + System.getProperty("os.name")\r
+ private final String userAgent = "NixNote/" + System.getProperty("os.name")\r
+"/"+System.getProperty("java.vendor") + "/"\r
+ System.getProperty("java.version") +";";\r
\r
public volatile String username = ""; \r
public volatile String password = ""; \r
public volatile String userStoreUrl;\r
- private final static String consumerKey = "baumgarte"; \r
- private final static String consumerSecret = "eb8b5740e17cb55f";\r
+// private final static String consumerKey = "baumgarte"; \r
+// private final static String consumerSecret = "eb8b5740e17cb55f";\r
public String noteStoreUrlBase;\r
private THttpClient userStoreTrans;\r
private TBinaryProtocol userStoreProt;\r
- private AuthenticationResult authResult;\r
+ //private AuthenticationResult authResult;\r
private AuthenticationResult linkedAuthResult;\r
private User user; \r
- private long authTimeRemaining;\r
+// private long authTimeRemaining;\r
public long authRefreshTime;\r
public long failedRefreshes = 0;\r
public THttpClient noteStoreTrans;\r
}\r
@Override\r
public void run() {\r
+ errorSharedNotebooks = new Vector<String>();\r
+ errorSharedNotebooksIgnored = new HashMap<String,String>();\r
try {\r
logger.log(logger.EXTREME, "Starting thread");\r
conn = new DatabaseConnection(logger, dburl, indexUrl, resourceUrl, dbuid, dbpswd, dbcpswd, 200);\r
while(keepRunning) {\r
+ logger.log(logger.EXTREME, "Blocking until work is found");\r
String work = workQueue.take();\r
+ logger.log(logger.LOW, "Dirty Notes Before Sync: " +new Integer(conn.getNoteTable().getDirtyCount()).toString());\r
logger.log(logger.EXTREME, "Work found: " +work);\r
if (work.equalsIgnoreCase("stop")) {\r
idle=false;\r
}\r
idle=false;\r
error=false;\r
- if (authRefreshNeeded == true || !isConnected) {\r
- logger.log(logger.EXTREME, "Refreshing connection");\r
- refreshConnection();\r
- }\r
if (syncNeeded) {\r
logger.log(logger.EXTREME, "SyncNeeded is true");\r
refreshNeeded=false;\r
syncSignal.errorDisconnect.emit();\r
status.message.emit(tr("Error synchronizing - see log for details."));\r
}\r
+ logger.log(logger.LOW, "Dirty Notes After Sync: " +new Integer(conn.getNoteTable().getDirtyCount()).toString());\r
}\r
} \r
catch (InterruptedException e1) {\r
// If we need to do a full sync.\r
logger.log(logger.LOW, "Full Sequence Before: " +syncState.getFullSyncBefore());\r
logger.log(logger.LOW, "Last Sequence Date: " +sequenceDate);\r
+ logger.log(logger.LOW, "Var Last Sequence Number: " +updateSequenceNumber);\r
+ logger.log(logger.LOW, "DB Last Sequence Number: " + conn.getSyncTable().getUpdateSequenceNumber());\r
if (syncState.getFullSyncBefore() > sequenceDate) {\r
logger.log(logger.EXTREME, "Full sequence date has expired");\r
sequenceDate = 0;\r
}\r
// Check for "special" sync instructions\r
String syncLinked = conn.getSyncTable().getRecord("FullLinkedNotebookSync");\r
- String syncShared = conn.getSyncTable().getRecord("FullLinkedNotebookSync");\r
+ String syncShared = conn.getSyncTable().getRecord("FullSharedNotebookSync");\r
String syncNotebooks = conn.getSyncTable().getRecord("FullNotebookSync");\r
String syncInkNoteImages = conn.getSyncTable().getRecord("FullInkNoteImageSync");\r
if (syncLinked != null) {\r
//*****************************************\r
//* Sync linked/shared notebooks \r
//*****************************************\r
- syncLinkedNotebooks();\r
- \r
+ //syncLinkedNotebooks();\r
+ conn.getNoteTable().getDirty();\r
if (!disableUploads) {\r
logger.log(logger.EXTREME, "Uploading changes");\r
// Synchronize remote changes\r
syncSignal.refreshLists.emit();\r
\r
if (!error) {\r
- logger.log(logger.EXTREME, "Sync completed. Errors=" +error);\r
+ logger.log(logger.LOW, "Sync completed. Errors=" +error);\r
if (!disableUploads) \r
status.message.emit(tr("Synchronizing complete"));\r
else\r
boolean error = false;\r
for (int i=0; i<expunged.size() && keepRunning; i++) {\r
\r
- if (authRefreshNeeded)\r
- if (!refreshConnection())\r
- return;\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
try {\r
if (expunged.get(i).type.equalsIgnoreCase("TAG")) {\r
// Sync the local notebooks with Evernote's\r
for (int i=0; i<notes.size() && keepRunning; i++) {\r
\r
- if (authRefreshNeeded)\r
- if (!refreshConnection())\r
- return;\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
Note enNote = notes.get(i);\r
try {\r
// Sync notes with Evernote\r
private void syncLocalNotes() {\r
logger.log(logger.HIGH, "Entering SyncRunner.syncNotes");\r
+ logger.log(logger.LOW, "Dirty local notes found: " +new Integer(conn.getNoteTable().getDirtyCount()).toString());\r
status.message.emit(tr("Sending local notes."));\r
\r
List<Note> notes = conn.getNoteTable().getDirty();\r
for (int i=0; i<notes.size() && keepRunning; i++) {\r
syncLocalNote(localNoteStore, notes.get(i), authToken);\r
}\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncNotes");\r
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncNotes");\r
\r
}\r
// Sync notes with Evernote\r
private void syncLocalNote(Client noteStore, Note enNote, String token) {\r
logger.log(logger.HIGH, "Entering SyncRunner.syncNotes");\r
status.message.emit(tr("Sending local notes."));\r
-\r
- if (authRefreshNeeded)\r
- if (!refreshConnection())\r
- return;\r
\r
if (enNote.isActive()) {\r
try {\r
- logger.log(logger.EXTREME, "Active dirty note found - non new");\r
if (enNote.getUpdateSequenceNum() > 0) {\r
+ logger.log(logger.EXTREME, "Active dirty note found - non new - " +enNote.getGuid());\r
+ logger.log(logger.EXTREME, "Fetching note content");\r
enNote = getNoteContent(enNote);\r
logger.log(logger.MEDIUM, "Updating note : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");\r
enNote = noteStore.updateNote(token, enNote);\r
} else { \r
- logger.log(logger.EXTREME, "Active dirty found - new note");\r
- logger.log(logger.MEDIUM, "Creating note : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");\r
+ logger.log(logger.EXTREME, "Active dirty found - new note " +enNote.getGuid());\r
String oldGuid = enNote.getGuid();\r
+ logger.log(logger.MEDIUM, "Fetching note content");\r
enNote = getNoteContent(enNote);\r
+ logger.log(logger.MEDIUM, "Creating note : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");\r
enNote = noteStore.createNote(token, enNote);\r
+ logger.log(logger.MEDIUM, "New note Guid : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");\r
noteSignal.guidChanged.emit(oldGuid, enNote.getGuid());\r
conn.getNoteTable().updateNoteGuid(oldGuid, enNote.getGuid());\r
}\r
// Sync the local notebooks with Evernote's\r
for (int i=0; i<notebooks.size() && keepRunning; i++) {\r
\r
- if (authRefreshNeeded)\r
- if (!refreshConnection())\r
- return;\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
Notebook enNotebook = notebooks.get(i);\r
try {\r
conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
} catch (EDAMUserException e) {\r
logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotebooks");\r
- logger.log(logger.LOW, e.toString()); \r
+ logger.log(logger.LOW, e.toString() + ": Stack : " +enNotebook.getStack()); \r
error = true;\r
} catch (EDAMSystemException e) {\r
logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotebooks");\r
\r
while(enTag!=null && loopCount < maxCount) {\r
loopCount++;\r
- if (authRefreshNeeded)\r
- if (!refreshConnection())\r
- return;\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
try {\r
if (enTag.getUpdateSequenceNum() > 0) {\r
logger.log(logger.EXTREME, "Beginning to send saved searches");\r
for (int i=0; i<searches.size() && keepRunning; i++) {\r
\r
- if (authRefreshNeeded)\r
- if (!refreshConnection())\r
- return;\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
SavedSearch enSearch = searches.get(i);\r
try {\r
enSearch = noteStore.createSearch(authToken, enSearch);\r
sequence = enSearch.getUpdateSequenceNum();\r
logger.log(logger.EXTREME, "Updating tag guid in local database");\r
- conn.getTagTable().updateTagGuid(oldGuid, enSearch.getGuid());\r
+ conn.getSavedSearchTable().updateSavedSearchGuid(oldGuid, enSearch.getGuid());\r
}\r
logger.log(logger.EXTREME, "Updating tag sequence in local database");\r
conn.getSavedSearchTable().updateSavedSearchSequence(enSearch.getGuid(), sequence);\r
\r
while(more && keepRunning) {\r
\r
- if (authRefreshNeeded)\r
- if (!refreshConnection())\r
- return;\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
int sequence = updateSequenceNumber;\r
try {\r
// conn.beginTransaction();\r
logger.log(logger.EXTREME, "Getting chunk from Evernote");\r
chunk = noteStore.getSyncChunk(authToken, sequence, chunkSize, fullSync);\r
+ logger.log(logger.LOW, "Chunk High Sequence: " +chunk.getChunkHighUSN());\r
} catch (EDAMUserException e) {\r
error = true;\r
e.printStackTrace();\r
// 3.) If a copy of the resource is in the local databbase and it is dirty and the hash doesn't match, we ignore it because there\r
// is a conflict. The note conflict should get a copy of the resource at that time.\r
\r
+ Note n = conn.getNoteTable().getNote(resource.getNoteGuid(), false, false, false, false, false);\r
+ if (n!=null) {\r
+ logger.log(logger.HIGH, "Resource for note " +n.getGuid() +" : " +n.getTitle());\r
+ }\r
boolean saveNeeded = false;\r
/* #1 */ Resource r = getEvernoteResource(noteStore, resource.getGuid(), true,true,true, authToken);\r
Resource l = conn.getNoteTable().noteResourceTable.getNoteResource(r.getGuid(), false);\r
if (l == null) {\r
+ logger.log(logger.HIGH, "Local resource not found");\r
saveNeeded = true;\r
} else {\r
/* #2 */ boolean isNoteDirty = conn.getNoteTable().isNoteDirty(r.getNoteGuid());\r
- if (!isNoteDirty)\r
+ if (!isNoteDirty) {\r
+ logger.log(logger.HIGH, "Local resource found, but is not dirty");\r
saveNeeded = true;\r
- else {\r
+ } else {\r
/* #3 */ String remoteHash = "";\r
if (r != null && r.getData() != null && r.getData().getBodyHash() != null)\r
remoteHash = byteArrayToHexString(r.getData().getBodyHash());\r
}\r
}\r
\r
+ logger.log(logger.HIGH, "Resource save needed: " +saveNeeded);\r
if (saveNeeded) \r
conn.getNoteTable().noteResourceTable.updateNoteResource(r, false);\r
if (r.getMime().equalsIgnoreCase("application/vnd.evernote.ink"))\r
downloadInkNoteImage(r.getGuid(), authToken);\r
+ \r
\r
}\r
// Sync remote notes\r
\r
if ((conflictingNote || fullSync) && !ignoreNote) {\r
logger.log(logger.EXTREME, "Saving Note");\r
- conn.getNoteTable().syncNote(n, false);\r
+ conn.getNoteTable().syncNote(n);\r
// The following was commented out because it caused a race condition on the database where resources \r
// may be lost. We do the same thing elsewhere;.\r
// noteSignal.noteChanged.emit(n.getGuid(), null); // Signal to ivalidate note cache \r
userStore = new UserStore.Client(userStoreProt, userStoreProt);\r
syncSignal.saveUserStore.emit(userStore);\r
try {\r
- authResult = userStore.authenticate(username, password, consumerKey, consumerSecret);\r
+ //authResult = userStore.authenticate(username, password, consumerKey, consumerSecret);\r
+ user = userStore.getUser(authToken);\r
} catch (EDAMUserException e) {\r
- QMessageBox mb = new QMessageBox(QMessageBox.Icon.Critical, "Error", "Incorrect username/password");\r
+ QMessageBox mb = new QMessageBox(QMessageBox.Icon.Critical, "Error", "Invalid Authorization");\r
mb.exec();\r
isConnected = false;\r
return false;\r
\r
boolean versionOk = false;\r
try {\r
- versionOk = userStore.checkVersion("NeverNote", \r
+ versionOk = userStore.checkVersion("NixNote", \r
com.evernote.edam.userstore.Constants.EDAM_VERSION_MAJOR, \r
com.evernote.edam.userstore.Constants.EDAM_VERSION_MINOR);\r
} catch (TException e) {\r
System.err.println("Incomatible EDAM client protocol version"); \r
isConnected = false;\r
}\r
- if (authResult != null) {\r
- user = authResult.getUser(); \r
- authToken = authResult.getAuthenticationToken(); \r
+ //if (authResult != null) {\r
+ //user = authResult.getUser(); \r
+ //authToken = authResult.getAuthenticationToken(); \r
noteStoreUrl = noteStoreUrlBase + user.getShardId();\r
syncSignal.saveAuthToken.emit(authToken);\r
syncSignal.saveNoteStore.emit(localNoteStore);\r
localNoteStore = \r
new NoteStore.Client(noteStoreProt, noteStoreProt); \r
isConnected = true;\r
- authTimeRemaining = authResult.getExpiration() - authResult.getCurrentTime();\r
- authRefreshTime = authTimeRemaining / 2;\r
- }\r
+ //authTimeRemaining = authResult.getExpiration() - authResult.getCurrentTime();\r
+ //authRefreshTime = authTimeRemaining / 2;\r
+ //}\r
\r
// Get user information\r
try {\r
public void enDisconnect() {\r
isConnected = false;\r
}\r
+ \r
+ /*\r
// Refresh the connection\r
private synchronized boolean refreshConnection() {\r
+ \r
logger.log(logger.EXTREME, "Entering SyncRunner.refreshConnection()");\r
// Calendar cal = Calendar.getInstance();\r
\r
return true;\r
}\r
\r
+ */\r
+ \r
public synchronized boolean addWork(String request) {\r
if (workQueue.offer(request))\r
return true;\r
}\r
\r
private Note getNoteContent(Note n) {\r
- n.setContent(conn.getNoteTable().getNoteContentBinary(n.getGuid()));\r
+ QTextCodec codec = QTextCodec.codecForLocale();\r
+ codec = QTextCodec.codecForName("UTF-8");\r
+ n.setContent(codec.toUnicode(new QByteArray(n.getContent())));\r
return n;\r
}\r
\r
//* Begin syncing shared notebooks \r
//******************************************\r
private void syncLinkedNotebooks() {\r
- logger.log(logger.MEDIUM, "Authenticating Shared Notebooks");\r
+ logger.log(logger.MEDIUM, "Authenticating linked Notebooks");\r
status.message.emit(tr("Synchronizing shared notebooks."));\r
List<LinkedNotebook> books = conn.getLinkedNotebookTable().getAll();\r
-\r
+ \r
+ errorSharedNotebooks.clear();\r
+ \r
for (int i=0; i<books.size(); i++) {\r
+ if (errorSharedNotebooksIgnored.containsKey(books.get(i).getGuid()))\r
+ break;\r
try {\r
+ logger.log(logger.EXTREME, "Checking notebook: " +books.get(i).getShareName());\r
long lastSyncDate = conn.getLinkedNotebookTable().getLastSequenceDate(books.get(i).getGuid());\r
int lastSequenceNumber = conn.getLinkedNotebookTable().getLastSequenceNumber(books.get(i).getGuid());\r
\r
+ logger.log(logger.EXTREME, "Last Sequence Number on file: " +lastSequenceNumber);\r
+ \r
// Authenticate to the owner's shard\r
String linkedNoteStoreUrl = noteStoreUrlBase + books.get(i).getShardId();\r
+ logger.log(logger.EXTREME, "linkedNoteStoreURL: " +linkedNoteStoreUrl);\r
THttpClient linkedNoteStoreTrans = new THttpClient(linkedNoteStoreUrl);\r
TBinaryProtocol linkedNoteStoreProt = new TBinaryProtocol(linkedNoteStoreTrans);\r
- Client linkedNoteStore = new NoteStore.Client(linkedNoteStoreProt, linkedNoteStoreProt); \r
+ Client linkedNoteStore = new NoteStore.Client(linkedNoteStoreProt, linkedNoteStoreProt); \r
\r
linkedAuthResult = null;\r
- if (books.get(i).getShareKey() != null)\r
+ if (books.get(i).getShareKey() != null) {\r
+ logger.log(logger.EXTREME, "Share Key Not Null: " +books.get(i).getShareKey());\r
linkedAuthResult = linkedNoteStore.authenticateToSharedNotebook(books.get(i).getShareKey(), authToken);\r
- else {\r
+ logger.log(logger.EXTREME, "Authentication Token" +linkedAuthResult.getAuthenticationToken());\r
+ } else {\r
+ logger.log(logger.EXTREME, "Share key is null");\r
linkedAuthResult = new AuthenticationResult();\r
linkedAuthResult.setAuthenticationToken("");\r
}\r
SyncState linkedSyncState = \r
linkedNoteStore.getLinkedNotebookSyncState(linkedAuthResult.getAuthenticationToken(), books.get(i));\r
if (linkedSyncState.getUpdateCount() > lastSequenceNumber) {\r
+ logger.log(logger.EXTREME, "Remote changes found");\r
if (lastSyncDate < linkedSyncState.getFullSyncBefore()) {\r
lastSequenceNumber = 0;\r
} \r
+ logger.log(logger.EXTREME, "Calling syncLinkedNotebook for " +books.get(i).getShareName());\r
syncLinkedNotebook(linkedNoteStore, books.get(i), \r
- lastSequenceNumber, linkedSyncState.getUpdateCount(), linkedAuthResult.getAuthenticationToken());\r
+ lastSequenceNumber, linkedSyncState.getUpdateCount(), authToken);\r
}\r
\r
// Synchronize local changes\r
} catch (EDAMNotFoundException e) {\r
status.message.emit(tr("Error synchronizing \" " +\r
books.get(i).getShareName()+"\". Please verify you still have access to that shared notebook."));\r
+ errorSharedNotebooks.add(books.get(i).getGuid());\r
+ errorSharedNotebooksIgnored.put(books.get(i).getGuid(), books.get(i).getGuid());\r
+ logger.log(logger.LOW, "Error synchronizing shared notebook. EDAMNotFound: "+e.getMessage());\r
+ logger.log(logger.LOW, e.getStackTrace());\r
error = true;\r
e.printStackTrace();\r
} catch (EDAMSystemException e) {\r
+ error = true;\r
logger.log(logger.LOW, "System error authenticating against shared notebook. "+\r
"Key: "+books.get(i).getShareKey() +" Error:" +e.getMessage());\r
e.printStackTrace();\r
} catch (TException e) {\r
+ error = true;\r
e.printStackTrace();\r
}\r
}\r
conn.getTagTable().removeUnusedLinkedTags();\r
conn.getTagTable().cleanupTags();\r
tagSignal.listChanged.emit();\r
+ return;\r
}\r
\r
\r
//* Linked notebook contents (from someone else's account)\r
//*************************************************************\r
private void syncLinkedNotebook(Client linkedNoteStore, LinkedNotebook book, int usn, int highSequence, String token) {\r
+ logger.log(logger.EXTREME, "Entering syncLinkedNotebook");\r
if (ignoreLinkedNotebooks.contains(book.getGuid()))\r
return;\r
List<Note> dirtyNotes = conn.getNoteTable().getDirtyLinkedNotes();\r
// Expunge notes\r
syncExpungedNotes(chunk);\r
\r
+ logger.log(logger.EXTREME, "Syncing remote notes: " +chunk.getNotesSize());\r
syncRemoteNotes(linkedNoteStore, chunk.getNotes(), fullSync, linkedAuthResult.getAuthenticationToken());\r
+ logger.log(logger.EXTREME, "Finding new linked tags");\r
findNewLinkedTags(linkedNoteStore, chunk.getNotes(), linkedAuthResult.getAuthenticationToken());\r
// Sync resources\r
+ logger.log(logger.EXTREME, "Synchronizing tags: " +chunk.getTagsSize());\r
for (int i=0; i<chunk.getResourcesSize(); i++) {\r
syncRemoteResource(linkedNoteStore, chunk.getResources().get(i), linkedAuthResult.getAuthenticationToken());\r
}\r
+ logger.log(logger.EXTREME, "Synchronizing linked notebooks: " +chunk.getNotebooksSize());\r
syncRemoteLinkedNotebooks(linkedNoteStore, chunk.getNotebooks(), false, book);\r
syncLinkedTags(chunk.getTags(), book.getGuid());\r
\r
noteSignal.noteChanged.emit(chunk.getNotes().get(i).getGuid(), null);\r
\r
// Expunge Notebook records\r
+ logger.log(logger.EXTREME, "Expunging linked notebooks: " +chunk.getExpungedLinkedNotebooksSize());\r
for (int i=0; i<chunk.getExpungedLinkedNotebooksSize(); i++) {\r
conn.getLinkedNotebookTable().expungeNotebook(chunk.getExpungedLinkedNotebooks().get(i), false);\r
}\r
syncError = true;\r
status.message.emit(tr("EDAM UserException synchronizing linked notbook. See the log for datails."));\r
e.printStackTrace();\r
- logger.log(logger.LOW, e.getMessage());\r
+ logger.log(logger.LOW, tr("EDAM UserException synchronizing linked notbook ")+ e.getMessage());\r
} catch (EDAMSystemException e) {\r
syncError = true;\r
status.message.emit(tr("EDAM SystemException synchronizing linked notbook. See the log for datails."));\r
e.printStackTrace();\r
- logger.log(logger.LOW, e.getMessage());\r
+ logger.log(logger.LOW, tr("EDAM SystemException synchronizing linked notbook. See the log for datails") +e.getMessage());\r
} catch (EDAMNotFoundException e) {\r
syncError = true;\r
- status.message.emit(tr("Notebook URL not found. Removing notobook " +book.getShareName()));\r
+ status.message.emit(tr("Notebook URL not found. Removing notobook ") +book.getShareName());\r
conn.getNotebookTable().deleteLinkedTags(book.getGuid());\r
conn.getLinkedNotebookTable().expungeNotebook(book.getGuid(), false);\r
- logger.log(logger.LOW, e.getMessage());\r
+ logger.log(logger.LOW, tr("Notebook URL not found. Removing notobook ") +e.getMessage());\r
} catch (TException e) {\r
syncError = true;\r
status.message.emit(tr("EDAM TException synchronizing linked notbook. See the log for datails."));\r
e.printStackTrace();\r
- logger.log(logger.LOW, e.getMessage());\r
+ logger.log(logger.LOW, tr("EDAM TException synchronizing linked notbook. See the log for datails." )+e.getMessage());\r
}\r
}\r
+ logger.log(logger.EXTREME, "leaving syncLinkedNotebook");\r
}\r
// Sync remote tags\r
private void syncLinkedTags(List<Tag> tags, String notebookGuid) {\r
if (notebooks != null) {\r
for (int i=0; i<notebooks.size() && keepRunning; i++) {\r
try {\r
+ logger.log(logger.EXTREME, "auth token:" +linkedAuthResult.getAuthenticationToken());\r
if (!linkedAuthResult.getAuthenticationToken().equals("")) {\r
SharedNotebook s = noteStore.getSharedNotebookByAuth(linkedAuthResult.getAuthenticationToken());\r
+ logger.log(logger.EXTREME, "share key:"+s.getShareKey() +" notebookGuid" +s.getNotebookGuid());\r
conn.getLinkedNotebookTable().setNotebookGuid(s.getShareKey(), s.getNotebookGuid());\r
readOnly = !s.isNotebookModifiable();\r
} else {\r
\r
// Synchronize changes locally done to linked notes\r
private void syncLocalLinkedNoteChanges(Client noteStore, LinkedNotebook book) {\r
+ logger.log(logger.EXTREME, "Entering SyncRunner.synclocalLinkedNoteChanges");\r
String notebookGuid = conn.getLinkedNotebookTable().getNotebookGuid(book.getGuid());\r
+ logger.log(logger.EXTREME, "Finding changes for " +book.getShareName() +":" +book.getGuid() + ":" +notebookGuid);\r
List<Note> notes = conn.getNoteTable().getDirtyLinked(notebookGuid);\r
+ logger.log(logger.EXTREME, "Number of changes found: " +notes.size());\r
for (int i=0; i<notes.size(); i++) {\r
+ logger.log(logger.EXTREME, "Calling syncLocalNote with key " +linkedAuthResult.getAuthenticationToken());\r
syncLocalNote(noteStore, notes.get(i), linkedAuthResult.getAuthenticationToken());\r
}\r
+ logger.log(logger.EXTREME, "Leaving SyncRunner.synclocalLinkedNoteChanges");\r
}\r
\r
}\r
OSDN Git Service
