/*\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
*/\r
package cx.fbn.nevernote.threads;\r
\r
+import java.io.BufferedOutputStream;\r
+import java.io.File;\r
+import java.io.FileOutputStream;\r
+import java.io.IOException;\r
+import java.io.InputStream;\r
+import java.io.UnsupportedEncodingException;\r
import java.net.UnknownHostException;\r
import java.util.ArrayList;\r
import java.util.Calendar;\r
import java.util.Date;\r
import java.util.GregorianCalendar;\r
+import java.util.HashMap;\r
import java.util.List;\r
+import java.util.TreeSet;\r
import java.util.Vector;\r
import java.util.concurrent.LinkedBlockingQueue;\r
\r
+import org.apache.http.HttpEntity;\r
+import org.apache.http.HttpResponse;\r
+import org.apache.http.NameValuePair;\r
+import org.apache.http.client.ClientProtocolException;\r
+import org.apache.http.client.HttpClient;\r
+import org.apache.http.client.entity.UrlEncodedFormEntity;\r
+import org.apache.http.client.methods.HttpPost;\r
+import org.apache.http.impl.client.DefaultHttpClient;\r
+import org.apache.http.message.BasicNameValuePair;\r
+import org.apache.http.protocol.HTTP;\r
import org.apache.thrift.TException;\r
import org.apache.thrift.protocol.TBinaryProtocol;\r
import org.apache.thrift.transport.THttpClient;\r
import com.evernote.edam.error.EDAMSystemException;\r
import com.evernote.edam.error.EDAMUserException;\r
import com.evernote.edam.notestore.NoteStore;\r
+import com.evernote.edam.notestore.NoteStore.Client;\r
import com.evernote.edam.notestore.SyncChunk;\r
import com.evernote.edam.notestore.SyncState;\r
import com.evernote.edam.type.Data;\r
+import com.evernote.edam.type.LinkedNotebook;\r
import com.evernote.edam.type.Note;\r
import com.evernote.edam.type.Notebook;\r
import com.evernote.edam.type.Resource;\r
import com.evernote.edam.type.SavedSearch;\r
+import com.evernote.edam.type.SharedNotebook;\r
import com.evernote.edam.type.Tag;\r
import com.evernote.edam.type.User;\r
import com.evernote.edam.userstore.AuthenticationResult;\r
import com.evernote.edam.userstore.UserStore;\r
+import com.trolltech.qt.core.QByteArray;\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 = "NixNote/" + System.getProperty("os.name")\r
+ +"/"+System.getProperty("java.vendor") + "/"\r
+ + System.getProperty("java.version") +";";\r
\r
- public volatile NoteStore.Client noteStore;\r
+ public volatile NoteStore.Client localNoteStore;\r
private UserStore.Client userStore;\r
\r
public volatile StatusSignal status;\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
public int updateSequenceNumber;\r
private boolean refreshNeeded;\r
private volatile LinkedBlockingQueue<String> workQueue;\r
-// private static int MAX_EMPTY_QUEUE_COUNT = 1;\r
private static int MAX_QUEUED_WAITING = 1000;\r
String dbuid;\r
String dburl;\r
+ String indexUrl;\r
+ String resourceUrl;\r
String dbpswd;\r
String dbcpswd;\r
+ private final TreeSet<String> ignoreTags;\r
+ private final TreeSet<String> ignoreNotebooks;\r
+ private final TreeSet<String> ignoreLinkedNotebooks;\r
+ private HashMap<String,String> badTagSync;\r
\r
\r
\r
- public SyncRunner(String logname, String u, String uid, String pswd, String cpswd) {\r
+ public SyncRunner(String logname, String u, String i, String r, String uid, String pswd, String cpswd) {\r
logger = new ApplicationLogger(logname);\r
\r
noteSignal = new NoteSignal();\r
searchSignal = new SavedSearchSignal();\r
syncSignal = new SyncSignal();\r
resourceSignal = new NoteResourceSignal();\r
+ resourceUrl = r;\r
+ indexUrl = i;\r
dbuid = uid;\r
dburl = u;\r
dbpswd = pswd;\r
authRefreshNeeded = false;\r
keepRunning = true;\r
idle = true;\r
- noteStore = null;\r
- userStore = null;\r
- authToken = null;\r
disableUploads = false;\r
+ ignoreTags = new TreeSet<String>();\r
+ ignoreNotebooks = new TreeSet<String>();\r
+ ignoreLinkedNotebooks = new TreeSet<String>();\r
+ \r
// setAutoDelete(false);\r
workQueue=new LinkedBlockingQueue<String>(MAX_QUEUED_WAITING);\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, dbuid, dbpswd, dbcpswd);\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
+ if (work.equalsIgnoreCase("stop")) {\r
+ idle=false;\r
return;\r
+ }\r
idle=false;\r
error=false;\r
- if (authRefreshNeeded == true) {\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
updateSequenceNumber = conn.getSyncTable().getUpdateSequenceNumber();\r
try {\r
logger.log(logger.EXTREME, "Beginning sync");\r
- evernoteSync();\r
+ evernoteSync(localNoteStore);\r
logger.log(logger.EXTREME, "Sync finished");\r
} catch (UnknownHostException e) {\r
status.message.emit(e.getMessage());\r
}\r
}\r
- dirtyNoteGuids = null;\r
idle=true;\r
logger.log(logger.EXTREME, "Signaling refresh finished. refreshNeeded=" +refreshNeeded);\r
syncSignal.finished.emit(refreshNeeded);\r
+ if (error) {\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
}\r
public void setNoteStore(NoteStore.Client c) {\r
logger.log(logger.EXTREME, "Setting NoteStore in sync thread");\r
- noteStore = c;\r
+ localNoteStore = c;\r
}\r
public void setUserStore(UserStore.Client c) {\r
logger.log(logger.EXTREME, "Setting UserStore in sync thread");\r
//***************************************************************\r
// Synchronize changes with Evernote\r
@SuppressWarnings("unused")\r
- private void evernoteSync() throws java.net.UnknownHostException {\r
+ private void evernoteSync(Client noteStore) throws java.net.UnknownHostException {\r
logger.log(logger.HIGH, "Entering SyncRunner.evernoteSync");\r
+ \r
+ // Rebuild list of tags & notebooks to ignore\r
+ ignoreNotebooks.clear();\r
+ List<String> ignore = conn.getSyncTable().getIgnoreRecords("NOTEBOOK");\r
+ for (int i=0; i<ignore.size(); i++) \r
+ ignoreNotebooks.add(ignore.get(i));\r
+ \r
+ ignore.clear();\r
+ ignore = conn.getSyncTable().getIgnoreRecords("LINKEDNOTEBOOK");\r
+ for (int i=0; i<ignore.size(); i++) \r
+ ignoreLinkedNotebooks.add(ignore.get(i));\r
+ \r
+ ignoreTags.clear();\r
+ ignore = conn.getSyncTable().getIgnoreRecords("TAG");\r
+ for (int i=0; i<ignore.size(); i++) \r
+ ignoreTags.add(ignore.get(i));\r
\r
+ // Make sure we are connected & should keep running\r
if (isConnected && keepRunning) {\r
error = false;\r
logger.log(logger.EXTREME, "Synchronizing with Evernote");\r
e1.printStackTrace();\r
status.message.emit(tr("User exception getting user account information. Aborting sync and disconnecting"));\r
syncSignal.errorDisconnect.emit();\r
+ error = true;\r
enDisconnect();\r
return;\r
} catch (EDAMSystemException e1) {\r
e1.printStackTrace();\r
status.message.emit(tr("System error user account information. Aborting sync and disconnecting!"));\r
syncSignal.errorDisconnect.emit();\r
+ error = true;\r
enDisconnect();\r
return;\r
} catch (TException e1) {\r
e1.printStackTrace();\r
syncSignal.errorDisconnect.emit();\r
+ error = true;\r
status.message.emit(tr("Transaction error getting user account information. Aborting sync and disconnecting!"));\r
enDisconnect();\r
return;\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
updateSequenceNumber = 0;\r
conn.getSyncTable().setUpdateSequenceNumber(0);\r
}\r
-\r
+ // Check for "special" sync instructions\r
+ String syncLinked = 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
+ downloadAllLinkedNotebooks(localNoteStore);\r
+ }\r
+ if (syncShared != null) {\r
+ downloadAllSharedNotebooks(localNoteStore);\r
+ }\r
+ if (syncNotebooks != null) {\r
+ downloadAllNotebooks(localNoteStore);\r
+ }\r
+ \r
+ if (syncInkNoteImages != null) {\r
+ List<String> guids = conn.getNoteTable().noteResourceTable.findInkNotes();\r
+ for (int i=0; i<guids.size(); i++) {\r
+ downloadInkNoteImage(guids.get(i), authToken);\r
+ }\r
+ conn.getSyncTable().deleteRecord("FullInkNoteImageSync");\r
+ }\r
+ \r
// If there are remote changes\r
logger.log(logger.LOW, "Update Count: " +syncState.getUpdateCount());\r
logger.log(logger.LOW, "Last Update Count: " +updateSequenceNumber);\r
logger.log(logger.EXTREME, "Refresh needed is true");\r
refreshNeeded = true;\r
logger.log(logger.EXTREME, "Downloading changes");\r
- syncRemoteToLocal();\r
+ syncRemoteToLocal(localNoteStore);\r
}\r
\r
+ //*****************************************\r
+ //* Sync linked/shared notebooks \r
+ //*****************************************\r
+ //syncLinkedNotebooks();\r
+ conn.getNoteTable().getDirty();\r
if (!disableUploads) {\r
logger.log(logger.EXTREME, "Uploading changes");\r
// Synchronize remote changes\r
if (!error)\r
- syncExpunged();\r
+ syncExpunged(localNoteStore);\r
+ if (!error)\r
+ syncLocalTags(localNoteStore);\r
if (!error)\r
- syncLocalTags();\r
+ syncLocalNotebooks(localNoteStore);\r
if (!error)\r
- syncLocalNotebooks();\r
+ syncLocalLinkedNotebooks(localNoteStore);\r
if (!error) \r
- syncDeletedNotes();\r
+ syncDeletedNotes(localNoteStore);\r
if (!error)\r
syncLocalNotes();\r
if (!error)\r
- syncLocalSavedSearches();\r
+ syncLocalSavedSearches(localNoteStore);\r
}\r
+ \r
+ status.message.emit(tr("Cleaning up"));\r
+ List<String> notes = conn.getNoteTable().expungeIgnoreSynchronizedNotes(conn.getSyncTable().getIgnoreRecords("NOTEBOOK"), \r
+ conn.getSyncTable().getIgnoreRecords("TAG"), conn.getSyncTable().getIgnoreRecords("LINKEDNOTEBOOK"));\r
+ if (notes.size() > 0)\r
+ syncSignal.refreshLists.emit();\r
+ \r
+ //*****************************************\r
+ //* End of synchronization\r
+ //*****************************************\r
if (refreshNeeded)\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
}\r
logger.log(logger.HIGH, "Leaving SyncRunner.evernoteSync");\r
}\r
+ \r
// Sync deleted items with Evernote\r
- private void syncExpunged() {\r
+ private void syncExpunged(Client noteStore) {\r
logger.log(logger.HIGH, "Entering SyncRunner.syncExpunged");\r
\r
List<DeletedItemRecord> expunged = conn.getDeletedTable().getAllDeleted();\r
boolean error = false;\r
- for (int i=0; i<expunged.size(); i++) {\r
- \r
- if (authRefreshNeeded)\r
- refreshConnection();\r
+ for (int i=0; i<expunged.size() && keepRunning; i++) {\r
+\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
try {\r
if (expunged.get(i).type.equalsIgnoreCase("TAG")) {\r
logger.log(logger.EXTREME, "Tag expunged");\r
updateSequenceNumber = noteStore.expungeTag(authToken, expunged.get(i).guid);\r
conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
- \r
+ conn.getSyncTable().setLastSequenceDate(sequenceDate);\r
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
+ conn.getDeletedTable().expungeDeletedItem(expunged.get(i).guid, "TAG"); \r
}\r
if (expunged.get(i).type.equalsIgnoreCase("NOTEBOOK")) {\r
logger.log(logger.EXTREME, "Notebook expunged");\r
updateSequenceNumber = noteStore.expungeNotebook(authToken, expunged.get(i).guid);\r
conn.getSyncTable().setLastSequenceDate(sequenceDate);\r
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
+ conn.getDeletedTable().expungeDeletedItem(expunged.get(i).guid, "NOTEBOOK");\r
}\r
if (expunged.get(i).type.equalsIgnoreCase("NOTE")) {\r
logger.log(logger.EXTREME, "Note expunged");\r
updateSequenceNumber = noteStore.deleteNote(authToken, expunged.get(i).guid);\r
+ refreshNeeded = true;\r
+ conn.getSyncTable().setLastSequenceDate(sequenceDate);\r
conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
+ conn.getDeletedTable().expungeDeletedItem(expunged.get(i).guid, "NOTE");\r
}\r
if (expunged.get(i).type.equalsIgnoreCase("SAVEDSEARCH")) {\r
logger.log(logger.EXTREME, "saved search expunged");\r
updateSequenceNumber = noteStore.expungeSearch(authToken, expunged.get(i).guid);\r
conn.getSyncTable().setLastSequenceDate(sequenceDate);\r
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
+ conn.getDeletedTable().expungeDeletedItem(expunged.get(i).guid, "SAVEDSEARCH");\r
}\r
} catch (EDAMUserException e) {\r
- logger.log(logger.LOW, "EDAM User Excepton in syncExpunged: " +expunged.get(i).guid);\r
- logger.log(logger.LOW, e.getStackTrace());\r
- error = true;\r
+ logger.log(logger.LOW, "EDAM User Excepton in syncExpunged: " +expunged.get(i).guid); // This can happen if we try to delete a deleted note\r
} catch (EDAMSystemException e) {\r
logger.log(logger.LOW, "EDAM System Excepton in syncExpunged: "+expunged.get(i).guid);\r
logger.log(logger.LOW, e.getStackTrace());\r
error=true;\r
} catch (EDAMNotFoundException e) {\r
logger.log(logger.LOW, "EDAM Not Found Excepton in syncExpunged: "+expunged.get(i).guid);\r
-// logger.log(logger.LOW, e.getStackTrace());\r
- //error=true;\r
} catch (TException e) {\r
logger.log(logger.LOW, "EDAM TExcepton in syncExpunged: "+expunged.get(i).guid);\r
logger.log(logger.LOW, e.getStackTrace());\r
logger.log(logger.HIGH, "Leaving SyncRunner.syncExpunged");\r
\r
}\r
- private void syncDeletedNotes() {\r
+ private void syncDeletedNotes(Client noteStore) {\r
if (syncDeletedContent)\r
return;\r
logger.log(logger.HIGH, "Entering SyncRunner.syncDeletedNotes");\r
// Sync the local notebooks with Evernote's\r
for (int i=0; i<notes.size() && keepRunning; i++) {\r
\r
- if (authRefreshNeeded)\r
- refreshConnection();\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
// Sync the local notebooks with Evernote's\r
for (int i=0; i<notes.size() && keepRunning; i++) {\r
+ syncLocalNote(localNoteStore, notes.get(i), authToken);\r
+ }\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
- refreshConnection();\r
- \r
- Note enNote = notes.get(i);\r
- if (enNote.isActive()) {\r
- try {\r
- logger.log(logger.EXTREME, "Active dirty note found - non new");\r
- if (enNote.getUpdateSequenceNum() > 0) {\r
- enNote = getNoteContent(enNote);\r
- logger.log(logger.MEDIUM, "Updating note : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");\r
- enNote = noteStore.updateNote(authToken, 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
- String oldGuid = enNote.getGuid();\r
- enNote = getNoteContent(enNote);\r
- enNote = noteStore.createNote(authToken, enNote);\r
- noteSignal.guidChanged.emit(oldGuid, enNote.getGuid());\r
- conn.getNoteTable().updateNoteGuid(oldGuid, enNote.getGuid());\r
- }\r
- updateSequenceNumber = enNote.getUpdateSequenceNum();\r
- logger.log(logger.EXTREME, "Saving note");\r
- conn.getNoteTable().updateNoteSequence(enNote.getGuid(), enNote.getUpdateSequenceNum());\r
- List<Resource> rl = enNote.getResources();\r
- logger.log(logger.EXTREME, "Getting note resources");\r
- for (int j=0; j<enNote.getResourcesSize() && keepRunning; j++) {\r
- Resource newRes = rl.get(j);\r
- Data d = newRes.getData();\r
- if (d!=null) { \r
- logger.log(logger.EXTREME, "Calculating resource hash");\r
- String hash = byteArrayToHexString(d.getBodyHash());\r
- logger.log(logger.EXTREME, "updating resources by hash");\r
- String oldGuid = conn.getNoteTable().noteResourceTable.getNoteResourceGuidByHashHex(enNote.getGuid(), hash);\r
- conn.getNoteTable().updateNoteResourceGuidbyHash(enNote.getGuid(), newRes.getGuid(), hash);\r
- resourceSignal.resourceGuidChanged.emit(enNote.getGuid(), oldGuid, newRes.getGuid());\r
- }\r
+ if (enNote.isActive()) {\r
+ try {\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 " +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
+ updateSequenceNumber = enNote.getUpdateSequenceNum();\r
+ logger.log(logger.EXTREME, "Saving note");\r
+ conn.getNoteTable().updateNoteSequence(enNote.getGuid(), enNote.getUpdateSequenceNum());\r
+ List<Resource> rl = enNote.getResources();\r
+ logger.log(logger.EXTREME, "Getting note resources");\r
+ for (int j=0; j<enNote.getResourcesSize() && keepRunning; j++) {\r
+ Resource newRes = rl.get(j);\r
+ Data d = newRes.getData();\r
+ if (d!=null) { \r
+ logger.log(logger.EXTREME, "Calculating resource hash");\r
+ String hash = byteArrayToHexString(d.getBodyHash());\r
+ logger.log(logger.EXTREME, "updating resources by hash");\r
+ String oldGuid = conn.getNoteTable().noteResourceTable.getNoteResourceGuidByHashHex(enNote.getGuid(), hash);\r
+ conn.getNoteTable().updateNoteResourceGuidbyHash(enNote.getGuid(), newRes.getGuid(), hash);\r
+ resourceSignal.resourceGuidChanged.emit(enNote.getGuid(), oldGuid, newRes.getGuid());\r
}\r
- logger.log(logger.EXTREME, "Resetting note dirty flag");\r
- conn.getNoteTable().resetDirtyFlag(enNote.getGuid());\r
- updateSequenceNumber = enNote.getUpdateSequenceNum();\r
- logger.log(logger.EXTREME, "Emitting note sequence number change");\r
- conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
-\r
- } catch (EDAMUserException e) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotes "+e);\r
- status.message.emit(tr("Error sending local note: ") +e.getParameter());\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (EDAMSystemException e) {\r
- logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotes "+e);\r
- status.message.emit(tr("Error: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (EDAMNotFoundException e) {\r
- logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalNotes " +e);\r
- status.message.emit(tr("Error sending local note: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (TException e) {\r
- logger.log(logger.LOW, "*** EDAM TExcepton syncLocalNotes "+e);\r
- status.message.emit(tr("Error sending local note: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
}\r
+ logger.log(logger.EXTREME, "Resetting note dirty flag");\r
+ conn.getNoteTable().resetDirtyFlag(enNote.getGuid());\r
+ updateSequenceNumber = enNote.getUpdateSequenceNum();\r
+ logger.log(logger.EXTREME, "Emitting note sequence number change");\r
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
+\r
+ } catch (EDAMUserException e) {\r
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotes "+e);\r
+ status.message.emit(tr("Error sending local note: ") +e.getParameter());\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
+ } catch (EDAMSystemException e) {\r
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotes "+e);\r
+ status.message.emit(tr("Error: ") +e);\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
+ } catch (EDAMNotFoundException e) {\r
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalNotes " +e);\r
+ status.message.emit(tr("Error sending local note: ") +e);\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
+ } catch (TException e) {\r
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalNotes "+e);\r
+ status.message.emit(tr("Error sending local note: ") +e);\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
}\r
}\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncNotes");\r
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalNote");\r
\r
}\r
+\r
// Sync Notebooks with Evernote\r
- private void syncLocalNotebooks() {\r
+ private void syncLocalNotebooks(Client noteStore) {\r
logger.log(logger.HIGH, "Entering SyncRunner.syncLocalNotebooks");\r
\r
status.message.emit(tr("Sending local notebooks."));\r
// Sync the local notebooks with Evernote's\r
for (int i=0; i<notebooks.size() && keepRunning; i++) {\r
\r
- if (authRefreshNeeded)\r
- refreshConnection();\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
}\r
// Sync Tags with Evernote\r
- private void syncLocalTags() {\r
+ private void syncLocalTags(Client noteStore) {\r
logger.log(logger.HIGH, "Entering SyncRunner.syncLocalTags");\r
List<Tag> remoteList = new ArrayList<Tag>();\r
status.message.emit(tr("Sending local tags."));\r
\r
int sequence;\r
\r
+ if (badTagSync == null)\r
+ badTagSync = new HashMap<String,String>();\r
+ else\r
+ badTagSync.clear();\r
+ \r
Tag enTag = findNextTag();\r
- while(enTag!=null) {\r
- if (authRefreshNeeded)\r
- refreshConnection();\r
+ \r
+ // This is a hack. Sometimes this function goes flookey and goes into a \r
+ // perpetual loop. This causes NeverNote to flood Evernote's servers.\r
+ // This is a safety valve to prevent unlimited loops.\r
+ int maxCount = conn.getTagTable().getDirty().size()+10;\r
+ int loopCount = 0;\r
+ \r
+ while(enTag!=null && loopCount < maxCount) {\r
+ loopCount++;\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
try {\r
if (enTag.getUpdateSequenceNum() > 0) {\r
updateSequenceNumber = sequence;\r
conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
} catch (EDAMUserException e) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags");\r
- logger.log(logger.LOW, e.toString()); \r
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags: " +enTag.getName());\r
+ logger.log(logger.LOW, e.toString());\r
+ badTagSync.put(enTag.getGuid(),null);\r
error = true;\r
} catch (EDAMSystemException e) {\r
- logger.log(logger.LOW, "** EDAM System Excepton syncLocalTags");\r
+ logger.log(logger.LOW, "** EDAM System Excepton syncLocalTags: " +enTag.getName());\r
logger.log(logger.LOW, e.toString()); \r
+ badTagSync.put(enTag.getGuid(),null);\r
error = true;\r
} catch (EDAMNotFoundException e) {\r
- logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalTags");\r
- logger.log(logger.LOW, e.toString()); \r
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalTags: " +enTag.getName());\r
+ logger.log(logger.LOW, e.toString());\r
+ badTagSync.put(enTag.getGuid(),null);\r
error = true;\r
} catch (TException e) {\r
- logger.log(logger.LOW, "*** EDAM TExcepton syncLocalTags");\r
- logger.log(logger.LOW, e.toString()); \r
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalTags: " +enTag.getName());\r
+ logger.log(logger.LOW, e.toString());\r
+ badTagSync.put(enTag.getGuid(),null);\r
error = true;\r
} \r
\r
}\r
logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalTags");\r
}\r
- // Sync Tags with Evernote\r
- private void syncLocalSavedSearches() {\r
+ private void syncLocalLinkedNotebooks(Client noteStore) {\r
+ logger.log(logger.HIGH, "Entering SyncRunner.syncLocalLinkedNotebooks");\r
+ \r
+ List<String> list = conn.getLinkedNotebookTable().getDirtyGuids();\r
+ for (int i=0; i<list.size(); i++) {\r
+ LinkedNotebook book = conn.getLinkedNotebookTable().getNotebook(list.get(i));\r
+ try {\r
+ noteStore.updateLinkedNotebook(authToken, book);\r
+ } catch (EDAMUserException e) {\r
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalLinkedNotebooks");\r
+ status.message.emit(tr("Error: ") +e);\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
+ e.printStackTrace();\r
+ } catch (EDAMNotFoundException e) {\r
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalLinkedNotebooks");\r
+ status.message.emit(tr("Error: ") +e);\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
+ e.printStackTrace();\r
+ } catch (EDAMSystemException e) {\r
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalLinkedNotebooks");\r
+ status.message.emit(tr("Error: ") +e);\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
+ e.printStackTrace();\r
+ } catch (TException e) {\r
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalLinkedNotebooks");\r
+ status.message.emit(tr("Error: ") +e);\r
+ logger.log(logger.LOW, e.toString()); \r
+ error = true;\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalLinkedNotebooks");\r
+ }\r
+ // Sync Saved Searches with Evernote\r
+ private void syncLocalSavedSearches(Client noteStore) {\r
logger.log(logger.HIGH, "Entering SyncRunner.syncLocalSavedSearches");\r
List<SavedSearch> remoteList = new ArrayList<SavedSearch>();\r
status.message.emit(tr("Sending saved searches."));\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
- refreshConnection();\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
error = true;\r
} \r
}\r
+\r
logger.log(logger.HIGH, "Entering SyncRunner.syncLocalSavedSearches");\r
} \r
\r
// Sync evernote changes with local database\r
- private void syncRemoteToLocal() {\r
+ private void syncRemoteToLocal(Client noteStore) {\r
logger.log(logger.HIGH, "Entering SyncRunner.syncRemoteToLocal");\r
\r
List<Note> dirtyNotes = conn.getNoteTable().getDirty();\r
\r
while(more && keepRunning) {\r
\r
- if (authRefreshNeeded)\r
- refreshConnection();\r
+// if (authRefreshNeeded)\r
+// if (!refreshConnection())\r
+// return;\r
\r
- chunk = null;\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
syncRemoteTags(chunk.getTags());\r
syncRemoteSavedSearches(chunk.getSearches());\r
syncRemoteNotebooks(chunk.getNotebooks());\r
- syncRemoteNotes(chunk.getNotes(), fullSync);\r
- syncRemoteResources(chunk.getResources());\r
+ syncRemoteNotes(noteStore, chunk.getNotes(), fullSync, authToken);\r
+ syncRemoteResources(noteStore, chunk.getResources());\r
+ syncRemoteLinkedNotebooks(chunk.getLinkedNotebooks());\r
+ \r
+ // Signal about any updated notes to invalidate the cache\r
+ for (int i=0; i<chunk.getNotesSize(); i++) \r
+ noteSignal.noteChanged.emit(chunk.getNotes().get(i).getGuid(), null); \r
+ syncExpungedNotes(chunk);\r
\r
- // Do the local deletes\r
- logger.log(logger.EXTREME, "Doing local deletes");\r
- List<String> guid = chunk.getExpungedNotes();\r
- if (guid != null) \r
- for (int i=0; i<guid.size() && keepRunning; i++) {\r
- logger.log(logger.EXTREME, "Expunging local note from database");\r
- conn.getNoteTable().expungeNote(guid.get(i), true, false);\r
- }\r
- guid = chunk.getExpungedNotebooks();\r
- if (guid != null)\r
- for (int i=0; i<guid.size() && keepRunning; i++) {\r
- logger.log(logger.EXTREME, "Expunging local notebook from database");\r
- conn.getNotebookTable().expungeNotebook(guid.get(i), false);\r
- }\r
- guid = chunk.getExpungedTags();\r
- if (guid != null)\r
- for (int i=0; i<guid.size() && keepRunning; i++) {\r
- logger.log(logger.EXTREME, "Expunging tags from local database");\r
- conn.getTagTable().expungeTag(guid.get(i), false);\r
- }\r
- guid = chunk.getExpungedSearches();\r
- if (guid != null) \r
- for (int i=0; i<guid.size() && keepRunning; i++) {\r
- logger.log(logger.EXTREME, "Expunging saved search from local database");\r
- conn.getSavedSearchTable().expungeSavedSearch(guid.get(i), false);\r
- }\r
-\r
\r
// Check for more notes\r
if (chunk.getChunkHighUSN() <= updateSequenceNumber) \r
\r
\r
// Save the chunk sequence number\r
- if (!error && chunk.getChunkHighUSN() > 0) {\r
+ if (!error && chunk.getChunkHighUSN() > 0 && keepRunning) {\r
logger.log(logger.EXTREME, "emitting sequence number to main thread");\r
updateSequenceNumber = chunk.getChunkHighUSN();\r
conn.getSyncTable().setLastSequenceDate(chunk.getCurrentTime());\r
conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
+// conn.commitTransaction();\r
}\r
\r
\r
pct = pct/evernoteUpdateCount;\r
status.message.emit(tr("Downloading ") +new Long(pct).toString()+tr("% complete."));\r
}\r
+// conn.commitTransaction();\r
}\r
-\r
logger.log(logger.HIGH, "Leaving SyncRunner.syncRemoteToLocal");\r
}\r
+ // Sync expunged notes\r
+ private void syncExpungedNotes(SyncChunk chunk) {\r
+ // Do the local deletes\r
+ logger.log(logger.EXTREME, "Doing local deletes");\r
+ List<String> guid = chunk.getExpungedNotes();\r
+ if (guid != null) {\r
+ for (int i=0; i<guid.size() && keepRunning; i++) {\r
+ String notebookGuid = "";\r
+ Note localNote = conn.getNoteTable().getNote(guid.get(i), false, false, false, false, false);\r
+ if (localNote != null) {\r
+ conn.getNoteTable().updateNoteSequence(guid.get(i), 0);\r
+ notebookGuid = localNote.getNotebookGuid();\r
+ }\r
+ if (!conn.getNotebookTable().isNotebookLocal(notebookGuid)) {\r
+ logger.log(logger.EXTREME, "Expunging local note from database");\r
+ conn.getNoteTable().expungeNote(guid.get(i), true, false);\r
+ }\r
+ }\r
+ }\r
+ guid = chunk.getExpungedNotebooks();\r
+ if (guid != null)\r
+ for (int i=0; i<guid.size() && keepRunning; i++) {\r
+ logger.log(logger.EXTREME, "Expunging local notebook from database");\r
+ conn.getNotebookTable().expungeNotebook(guid.get(i), false);\r
+ }\r
+ guid = chunk.getExpungedTags();\r
+ if (guid != null)\r
+ for (int i=0; i<guid.size() && keepRunning; i++) {\r
+ logger.log(logger.EXTREME, "Expunging tags from local database");\r
+ conn.getTagTable().expungeTag(guid.get(i), false);\r
+ }\r
+ guid = chunk.getExpungedSearches();\r
+ if (guid != null) \r
+ for (int i=0; i<guid.size() && keepRunning; i++) {\r
+ logger.log(logger.EXTREME, "Expunging saved search from local database");\r
+ conn.getSavedSearchTable().expungeSavedSearch(guid.get(i), false);\r
+ }\r
+ guid = chunk.getExpungedLinkedNotebooks();\r
+ if (guid != null) \r
+ for (int i=0; i<guid.size() && keepRunning; i++) {\r
+ logger.log(logger.EXTREME, "Expunging linked notebook from local database");\r
+ conn.getLinkedNotebookTable().expungeNotebook(guid.get(i), false);\r
+ }\r
+\r
+ }\r
// Sync remote tags\r
private void syncRemoteTags(List<Tag> tags) {\r
logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteTags");\r
}\r
logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteTags");\r
}\r
- // Sync remote tags\r
+ // Sync remote saved searches\r
private void syncRemoteSavedSearches(List<SavedSearch> searches) {\r
logger.log(logger.EXTREME, "Entering SyncRunner.syncSavedSearches");\r
if (searches != null) {\r
}\r
logger.log(logger.EXTREME, "Leaving SyncRunner.syncSavedSearches");\r
}\r
+ // Sync remote linked notebooks\r
+ private void syncRemoteLinkedNotebooks(List<LinkedNotebook> books) {\r
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncLinkedNotebooks");\r
+ if (books != null) {\r
+ for (int i=0; i<books.size() && keepRunning; i++) {\r
+ conn.getLinkedNotebookTable().updateNotebook(books.get(i), false); \r
+ }\r
+ }\r
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncLinkedNotebooks");\r
+ }\r
// Sync remote Notebooks 2\r
private void syncRemoteNotebooks(List<Notebook> notebooks) {\r
logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteNotebooks");\r
if (oldGuid != null && !conn.getNotebookTable().isNotebookLocal(oldGuid) && !notebooks.get(i).getGuid().equalsIgnoreCase(oldGuid))\r
conn.getNotebookTable().updateNotebookGuid(oldGuid, notebooks.get(i).getGuid());\r
conn.getNotebookTable().syncNotebook(notebooks.get(i), false); \r
+ \r
+ // Synchronize shared notebook information\r
+// if (notebooks.get(i).getSharedNotebookIdsSize() > 0) {\r
+// conn.getSharedNotebookTable().expungeNotebookByGuid(notebooks.get(i).getGuid(), false);\r
+// for (int j=0; j<notebooks.get(i).getSharedNotebookIdsSize(); j++) {\r
+// syncRemoteSharedNotebook(notebooks.get(i).getGuid(), notebooks.get(i).getSharedNotebookIds().get(j), authToken);\r
+// }\r
+// }\r
}\r
} \r
logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteNotebooks");\r
}\r
+ // Sync remote shared notebook\r
+// private void syncRemoteSharedNotebook(String guid, Long id, String token) {\r
+// List<SharedNotebook> books = noteStore.getSharedNotebookByAuth(authToken);\r
+// }\r
// Sync remote Resources\r
- private void syncRemoteResources(List<Resource> resource) {\r
+ private void syncRemoteResources(Client noteStore, List<Resource> resource) {\r
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteResources");\r
+ if (resource != null) {\r
+ for (int i=0; i<resource.size() && keepRunning; i++) {\r
+ syncRemoteResource(noteStore, resource.get(i), authToken);\r
+ }\r
+ }\r
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteResources");\r
+ }\r
+ // Sync remote resource\r
+ private void syncRemoteResource(Client noteStore, Resource resource, String authToken) {\r
// This is how the logic for this works.\r
// 1.) If the resource is not in the local database, we add it.\r
// 2.) If a copy of the resource is in the local database and the note isn't dirty, we update the local copy\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
- logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteResources");\r
- if (resource != null) {\r
- for (int i=0; i<resource.size() && keepRunning; i++) {\r
- boolean saveNeeded = false;\r
-/* #1 */ Resource r = getEvernoteResource(resource.get(i).getGuid(), true,true,true);\r
- Resource l = conn.getNoteTable().noteResourceTable.getNoteResource(r.getGuid(), false);\r
- if (l == null) {\r
- saveNeeded = true;\r
- } else {\r
-/* #2 */ boolean isNoteDirty = conn.getNoteTable().isNoteDirty(r.getNoteGuid());\r
- if (!isNoteDirty)\r
- saveNeeded = true;\r
- else {\r
-/* #3 */ String remoteHash = "";\r
- if (r != null && r.getData() != null && r.getData().getBodyHash() != null)\r
- remoteHash = byteArrayToHexString(r.getData().getBodyHash());\r
- String localHash = "";\r
- if (l != null && l.getData() != null && l.getData().getBodyHash() != null)\r
- remoteHash = byteArrayToHexString(l.getData().getBodyHash());\r
- \r
- if (localHash.equalsIgnoreCase(remoteHash))\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
- }\r
- }\r
- \r
- if (saveNeeded) \r
- conn.getNoteTable().noteResourceTable.updateNoteResource(r, false);\r
+ } else {\r
+ /* #2 */ boolean isNoteDirty = conn.getNoteTable().isNoteDirty(r.getNoteGuid());\r
+ if (!isNoteDirty) {\r
+ logger.log(logger.HIGH, "Local resource found, but is not dirty");\r
+ saveNeeded = true;\r
+ } else {\r
+ /* #3 */ String remoteHash = "";\r
+ if (r != null && r.getData() != null && r.getData().getBodyHash() != null)\r
+ remoteHash = byteArrayToHexString(r.getData().getBodyHash());\r
+ String localHash = "";\r
+ if (l != null && l.getData() != null && l.getData().getBodyHash() != null)\r
+ remoteHash = byteArrayToHexString(l.getData().getBodyHash());\r
+ \r
+ if (localHash.equalsIgnoreCase(remoteHash))\r
+ saveNeeded = true;\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
- }\r
- logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteResources");\r
}\r
- // Sync remote notebooks\r
- private void syncRemoteNotes(List<Note> note, boolean fullSync) {\r
+ // Sync remote notes\r
+ private void syncRemoteNotes(Client noteStore, List<Note> note, boolean fullSync, String token) {\r
logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteNotes");\r
if (note != null) {\r
for (int i=0; i<note.size() && keepRunning; i++) {\r
- Note n = getEvernoteNote(note.get(i).getGuid(), true, fullSync, true,true);\r
- if (n!=null) {\r
- \r
- // Basically, this is how the sync logic for a note works.\r
- // If the remote note has changed and the local has not, we\r
- // accept the change.\r
- // If both the local & remote have changed but the sequence\r
- // numbers are the same, we don't accept the change. This\r
- // seems to happen when attachments are indexed by the server.\r
- // If both the local & remote have changed and the sequence numbers\r
- // are different we move the local copy to a local notebook (making sure\r
- // to copy all resources) and we accept the new one. \r
- boolean conflictingNote = true;\r
- logger.log(logger.EXTREME, "Checking for duplicate note " +n.getGuid());\r
- if (dirtyNoteGuids.contains(n.getGuid())) { \r
- logger.log(logger.EXTREME, "Conflict check beginning");\r
- conflictingNote = checkForConflict(n);\r
- logger.log(logger.EXTREME, "Conflict check results " +conflictingNote);\r
- if (conflictingNote)\r
- moveConflictingNote(n.getGuid());\r
- }\r
- if (conflictingNote || fullSync) {\r
- logger.log(logger.EXTREME, "Saving Note");\r
- conn.getNoteTable().syncNote(n, false);\r
- noteSignal.noteChanged.emit(n.getGuid(), null); // Signal to ivalidate note cache\r
- noteSignal.noteDownloaded.emit(n, true); // Signal to add note to index\r
- logger.log(logger.EXTREME, "Note Saved");\r
- if (fullSync && n.getResources() != null) {\r
- for (int q=0; q<n.getResources().size() && keepRunning; q++) {\r
- logger.log(logger.EXTREME, "Getting note resources.");\r
- conn.getNoteTable().noteResourceTable.updateNoteResource(n.getResources().get(q), false);\r
- }\r
- }\r
+ Note n = getEvernoteNote(noteStore, note.get(i).getGuid(), true, fullSync, true,true, token);\r
+ syncRemoteNote(n, fullSync, token);\r
+ }\r
+ }\r
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteNotes");\r
+ }\r
+ private void syncRemoteNote(Note n, boolean fullSync, String token) {\r
+ if (n!=null) {\r
+ \r
+ // Basically, this is how the sync logic for a note works.\r
+ // If the remote note has changed and the local has not, we\r
+ // accept the change.\r
+ // If both the local & remote have changed but the sequence\r
+ // numbers are the same, we don't accept the change. This\r
+ // seems to happen when attachments are indexed by the server.\r
+ // If both the local & remote have changed and the sequence numbers\r
+ // are different we move the local copy to a local notebook (making sure\r
+ // to copy all resources) and we accept the new one. \r
+ boolean conflictingNote = true;\r
+ logger.log(logger.EXTREME, "Checking for duplicate note " +n.getGuid());\r
+ if (dirtyNoteGuids != null && dirtyNoteGuids.contains(n.getGuid())) { \r
+ logger.log(logger.EXTREME, "Conflict check beginning");\r
+ conflictingNote = checkForConflict(n);\r
+ logger.log(logger.EXTREME, "Conflict check results " +conflictingNote);\r
+ if (conflictingNote)\r
+ moveConflictingNote(n.getGuid());\r
+ }\r
+ boolean ignoreNote = false;\r
+ if (ignoreNotebooks.contains(n.getNotebookGuid()))\r
+ ignoreNote = true;\r
+ for (int i=0; i<n.getTagGuidsSize(); i++) {\r
+ if (ignoreTags.contains(n.getTagGuids().get(i))) {\r
+ ignoreNote = true;\r
+ i=n.getTagGuidsSize();\r
+ }\r
+ }\r
+ \r
+ if ((conflictingNote || fullSync) && !ignoreNote) {\r
+ logger.log(logger.EXTREME, "Saving Note");\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
+ noteSignal.noteDownloaded.emit(n, true); // Signal to add note to index\r
+ logger.log(logger.EXTREME, "Note Saved");\r
+ if (fullSync && n.getResources() != null) {\r
+ for (int q=0; q<n.getResources().size() && keepRunning; q++) {\r
+ logger.log(logger.EXTREME, "Getting note resources.");\r
+ conn.getNoteTable().noteResourceTable.updateNoteResource(n.getResources().get(q), false);\r
+ if (n.getResources().get(q).getMime().equalsIgnoreCase("application/vnd.evernote.ink"))\r
+ downloadInkNoteImage(n.getResources().get(q).getGuid(), token);\r
}\r
}\r
}\r
}\r
- logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteNotes");\r
}\r
- private Note getEvernoteNote(String guid, boolean withContent, boolean withResourceData, boolean withResourceRecognition, boolean withResourceAlternateData) { \r
+ private Note getEvernoteNote(Client noteStore, String guid, boolean withContent, boolean withResourceData, boolean withResourceRecognition, boolean withResourceAlternateData, String token) { \r
Note n = null;\r
try {\r
logger.log(logger.EXTREME, "Retrieving note " +guid);\r
- n = noteStore.getNote(authToken, guid, withContent, withResourceData, withResourceRecognition, withResourceAlternateData);\r
+ n = noteStore.getNote(token, guid, withContent, withResourceData, withResourceRecognition, withResourceAlternateData);\r
logger.log(logger.EXTREME, "Note " +guid +" has been retrieved.");\r
} catch (EDAMUserException e) {\r
logger.log(logger.LOW, "*** EDAM User Excepton getEvernoteNote");\r
}\r
return n;\r
}\r
- private Resource getEvernoteResource(String guid, boolean withData, boolean withRecognition, boolean withAttributes) { \r
+ private Resource getEvernoteResource(Client noteStore, String guid, boolean withData, boolean withRecognition, boolean withAttributes, String token) { \r
Resource n = null;\r
try {\r
logger.log(logger.EXTREME, "Retrieving resource " +guid);\r
- n = noteStore.getResource(authToken, guid, withData, withRecognition, withAttributes, withAttributes);\r
+ n = noteStore.getResource(token, guid, withData, withRecognition, withAttributes, withAttributes);\r
logger.log(logger.EXTREME, "Resource " +guid +" has been retrieved.");\r
} catch (EDAMUserException e) {\r
logger.log(logger.LOW, "*** EDAM User Excepton getEvernoteNote");\r
newBook.setPublished(false);\r
\r
conn.getNotebookTable().addNotebook(newBook, false, true);\r
+ notebookSignal.listChanged.emit();\r
notebookGuid = newBook.getGuid();\r
+ refreshNeeded = true;\r
}\r
\r
// Now that we have a good notebook guid, we need to move the conflicting note\r
conn.getNoteTable().updateNoteGuid(guid, newGuid);\r
conn.getNoteTable().updateNoteNotebook(newGuid, notebookGuid, true);\r
\r
- \r
+ noteSignal.notebookChanged.emit(newGuid, notebookGuid);\r
+ refreshNeeded = true;\r
noteSignal.guidChanged.emit(guid,newGuid);\r
}\r
\r
- \r
+\r
\r
\r
//******************************************************\r
// Find the parent. If the parent has a sequence > 0 then it is a good\r
// parent.\r
for (int i=0; i<tags.size() && keepRunning; i++) {\r
- if (tags.get(i).getParentGuid() == null) {\r
- logger.log(logger.HIGH, "Leaving SyncRunner.findNextTag - tag found without parent");\r
- return tags.get(i);\r
- }\r
- Tag parentTag = conn.getTagTable().getTag(tags.get(i).getParentGuid());\r
- if (parentTag.getUpdateSequenceNum() > 0) {\r
- logger.log(logger.HIGH, "Leaving SyncRunner.findNextTag - tag found");\r
- return tags.get(i);\r
+ if (!badTagSync.containsKey(tags.get(i).getGuid())) {\r
+ if (tags.get(i).getParentGuid() == null) {\r
+ logger.log(logger.HIGH, "Leaving SyncRunner.findNextTag - tag found without parent");\r
+ return tags.get(i);\r
+ }\r
+ Tag parentTag = conn.getTagTable().getTag(tags.get(i).getParentGuid());\r
+ if (parentTag.getUpdateSequenceNum() > 0) {\r
+ logger.log(logger.HIGH, "Leaving SyncRunner.findNextTag - tag found");\r
+ return tags.get(i);\r
+ }\r
}\r
}\r
\r
public boolean enConnect() {\r
try {\r
userStoreTrans = new THttpClient(userStoreUrl);\r
+ userStoreTrans.setCustomHeader("User-Agent", userAgent);\r
} catch (TTransportException e) {\r
QMessageBox mb = new QMessageBox(QMessageBox.Icon.Critical, "Transport Excepton", e.getLocalizedMessage());\r
mb.exec();\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("Dave's EDAMDemo (Java)", \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(noteStore);\r
+ syncSignal.saveNoteStore.emit(localNoteStore);\r
\r
\r
try {\r
noteStoreTrans = new THttpClient(noteStoreUrl);\r
+ noteStoreTrans.setCustomHeader("User-Agent", userAgent);\r
} catch (TTransportException e) {\r
QMessageBox mb = new QMessageBox(QMessageBox.Icon.Critical, "Transport Excepton", e.getLocalizedMessage());\r
mb.exec();\r
isConnected = false;\r
} \r
noteStoreProt = new TBinaryProtocol(noteStoreTrans);\r
- noteStore = \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 void refreshConnection() {\r
+ private synchronized boolean refreshConnection() {\r
+ \r
logger.log(logger.EXTREME, "Entering SyncRunner.refreshConnection()");\r
// Calendar cal = Calendar.getInstance();\r
\r
// If we are not connected let's get out of here\r
if (!isConnected)\r
- return;\r
+ return false;\r
\r
// If we fail too many times, then let's give up.\r
if (failedRefreshes >=5) {\r
logger.log(logger.EXTREME, "Refresh attempts have failed. Disconnecting.");\r
isConnected = false;\r
- return;\r
+ status.message.emit(tr("Unable to synchronize - Authentication failed"));\r
+ return false;\r
}\r
\r
// If this is the first time through, then we need to set this\r
if (userStore != null && authToken != null) \r
newAuth = userStore.refreshAuthentication(authToken); \r
else\r
- return;\r
+ return false;\r
logger.log(logger.EXTREME, "UserStore.refreshAuthentication has succeeded.");\r
} catch (EDAMUserException e) {\r
e.printStackTrace();\r
syncSignal.authRefreshComplete.emit(false);\r
failedRefreshes++;\r
- return;\r
+ return false;\r
} catch (EDAMSystemException e) {\r
e.printStackTrace();\r
syncSignal.authRefreshComplete.emit(false);\r
failedRefreshes++;\r
- return; \r
+ return false; \r
} catch (TException e) { \r
e.printStackTrace();\r
syncSignal.authRefreshComplete.emit(false);\r
failedRefreshes++;\r
- return;\r
+ return false;\r
}\r
\r
// If we didn't get a good auth, then we've failed\r
if (newAuth == null) {\r
failedRefreshes++;\r
+ status.message.emit(tr("Unable to synchronize - Authentication failed"));\r
logger.log(logger.EXTREME, "Authentication failure #" +failedRefreshes);\r
+ status.message.emit(tr("Unable to synchronize - Authentication failed"));\r
syncSignal.authRefreshComplete.emit(false);\r
- return;\r
+ return false;\r
}\r
\r
// We got a good token. Now we need to setup the time to renew it.\r
// failedRefreshes++;\r
// syncSignal.authRefreshComplete.emit(false);\r
// }\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
+\r
+\r
+ //*********************************************************\r
+ //* Special download instructions. Used for DB upgrades\r
+ //*********************************************************\r
+ private void downloadAllSharedNotebooks(Client noteStore) {\r
+ try {\r
+ List<SharedNotebook> books = noteStore.listSharedNotebooks(authToken);\r
+ logger.log(logger.LOW, "Shared notebooks found = " +books.size());\r
+ for (int i=0; i<books.size(); i++) {\r
+ conn.getSharedNotebookTable().updateNotebook(books.get(i), false);\r
+ }\r
+ conn.getSyncTable().deleteRecord("FullSharedNotebookSync");\r
+ } catch (EDAMUserException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("User exception Listing shared notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (EDAMSystemException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("System exception Listing shared notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (TException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("Transaction exception Listing shared notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (EDAMNotFoundException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("EDAM Not Found exception Listing shared notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ }\r
+ }\r
+ private void downloadAllNotebooks(Client noteStore) {\r
+ try {\r
+ List<Notebook> books = noteStore.listNotebooks(authToken);\r
+ logger.log(logger.LOW, "Shared notebooks found = " +books.size());\r
+ for (int i=0; i<books.size(); i++) {\r
+ conn.getNotebookTable().updateNotebook(books.get(i), false);\r
+ }\r
+ conn.getSyncTable().deleteRecord("FullNotebookSync");\r
+ } catch (EDAMUserException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("User exception Listing notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (EDAMSystemException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("System exception Listing notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (TException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("Transaction exception Listing notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ }\r
+ }\r
+ private void downloadAllLinkedNotebooks(Client noteStore) {\r
+ try {\r
+ List<LinkedNotebook> books = noteStore.listLinkedNotebooks(authToken);\r
+ logger.log(logger.LOW, "Linked notebooks found = " +books.size());\r
+ for (int i=0; i<books.size(); i++) {\r
+ conn.getLinkedNotebookTable().updateNotebook(books.get(i), false);\r
+ }\r
+ conn.getSyncTable().deleteRecord("FullLinkedNotebookSync");\r
+ } catch (EDAMUserException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("User exception Listing linked notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (EDAMSystemException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("System exception Listing linked notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (TException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("Transaction exception Listing lineked notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ return;\r
+ } catch (EDAMNotFoundException e1) {\r
+ e1.printStackTrace();\r
+ status.message.emit(tr("EDAM Not Found exception Listing linked notebooks."));\r
+ logger.log(logger.LOW, e1.getMessage());\r
+ }\r
+ }\r
+\r
+ \r
+ private void downloadInkNoteImage(String guid, String authToken) {\r
+ String urlBase = noteStoreUrl.replace("/edam/note/", "/shard/") + "/res/"+guid+".ink?slice=";\r
+// urlBase = "https://www.evernote.com/shard/s1/res/52b567a9-54ae-4a08-afc5-d5bae275b2a8.ink?slice=";\r
+ Integer slice = 1;\r
+ Resource r = conn.getNoteTable().noteResourceTable.getNoteResource(guid, false);\r
+ conn.getInkImagesTable().expungeImage(r.getGuid());\r
+ int sliceCount = 1+((r.getHeight()-1)/480);\r
+ HttpClient http = new DefaultHttpClient();\r
+ for (int i=0; i<sliceCount; i++) {\r
+ String url = urlBase + slice.toString();\r
+ HttpPost post = new HttpPost(url);\r
+ post.getParams().setParameter("auth", authToken);\r
+ List <NameValuePair> nvps = new ArrayList <NameValuePair>();\r
+ nvps.add(new BasicNameValuePair("auth", authToken));\r
+\r
+ try {\r
+ post.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));\r
+ } catch (UnsupportedEncodingException e1) {\r
+ e1.printStackTrace();\r
+ }\r
+ try {\r
+ HttpResponse response = http.execute(post);\r
+ HttpEntity resEntity = response.getEntity();\r
+ InputStream is = resEntity.getContent();\r
+ QByteArray data = writeToFile(is);\r
+ conn.getInkImagesTable().saveImage(guid, slice, data);\r
+ } catch (ClientProtocolException e) {\r
+ e.printStackTrace();\r
+ } catch (IOException e) {\r
+ e.printStackTrace();\r
+ }\r
+\r
+ slice++;\r
+ }\r
+ http.getConnectionManager().shutdown(); \r
+ noteSignal.noteChanged.emit(r.getNoteGuid(), null); // Signal to ivalidate note cache\r
+ }\r
+ \r
+ \r
+ public QByteArray writeToFile(InputStream iStream) throws IOException {\r
+\r
+ File temp = File.createTempFile("nn-inknote-temp", ".png");\r
+\r
+ // Save InputStream to the file.\r
+ BufferedOutputStream fOut = null;\r
+ try {\r
+ fOut = new BufferedOutputStream(new FileOutputStream(temp));\r
+ byte[] buffer = new byte[32 * 1024];\r
+ int bytesRead = 0;\r
+ while ((bytesRead = iStream.read(buffer)) != -1) {\r
+ fOut.write(buffer, 0, bytesRead);\r
+ }\r
+ }\r
+ finally {\r
+ iStream.close();\r
+ fOut.close();\r
+ }\r
+ QFile tempFile = new QFile(temp.getAbsoluteFile().toString());\r
+ tempFile.open(OpenModeFlag.ReadOnly);\r
+ QByteArray data = tempFile.readAll();\r
+ tempFile.close();\r
+ tempFile.remove();\r
+ return data;\r
+ }\r
+ \r
+ \r
+ //******************************************\r
+ //* Begin syncing shared notebooks \r
+ //******************************************\r
+ private void syncLinkedNotebooks() {\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
+ 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
+\r
+ linkedAuthResult = 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
+ 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(), authToken);\r
+ }\r
+ \r
+ // Synchronize local changes\r
+ syncLocalLinkedNoteChanges(linkedNoteStore, books.get(i));\r
+ \r
+ } catch (EDAMUserException e) {\r
+ e.printStackTrace();\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
+ \r
+ // Cleanup tags\r
+ conn.getTagTable().removeUnusedLinkedTags();\r
+ conn.getTagTable().cleanupTags();\r
+ tagSignal.listChanged.emit();\r
+ return;\r
+ }\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
+ if (dirtyNoteGuids == null) \r
+ dirtyNoteGuids = new Vector<String>();\r
+\r
+ for (int i=0; i<dirtyNotes.size() && keepRunning; i++) {\r
+ dirtyNoteGuids.add(dirtyNotes.get(i).getGuid());\r
+ }\r
+ boolean fullSync = false;\r
+ if (usn == 0)\r
+ fullSync = true;\r
+ boolean syncError = false;\r
+ while (usn < highSequence && !syncError) {\r
+ refreshNeeded = true;\r
+ try {\r
+ SyncChunk chunk = \r
+ linkedNoteStore.getLinkedNotebookSyncChunk(token, book, usn, 10, fullSync);\r
+ \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
+ // Go through & signal any notes that have changed so we can refresh the user's view\r
+ for (int i=0; i<chunk.getNotesSize(); i++) \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
+ usn = chunk.getChunkHighUSN();\r
+ conn.getLinkedNotebookTable().setLastSequenceDate(book.getGuid(),chunk.getCurrentTime());\r
+ conn.getLinkedNotebookTable().setLastSequenceNumber(book.getGuid(),chunk.getChunkHighUSN());\r
+ } catch (EDAMUserException e) {\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, 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, 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
+ conn.getNotebookTable().deleteLinkedTags(book.getGuid());\r
+ conn.getLinkedNotebookTable().expungeNotebook(book.getGuid(), false);\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, 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
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteTags");\r
+ if (tags != null) {\r
+ for (int i=0; i<tags.size() && keepRunning; i++) {\r
+ conn.getTagTable().syncLinkedTag(tags.get(i), notebookGuid, false);\r
+ }\r
+ }\r
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteTags");\r
+ }\r
+ \r
+ // Sync notebooks from a linked notebook\r
+ private void syncRemoteLinkedNotebooks(Client noteStore, List<Notebook> notebooks, boolean readOnly, LinkedNotebook linked) {\r
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteNotebooks");\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
+ readOnly = true;\r
+ }\r
+ notebooks.get(i).setName(linked.getShareName());\r
+ notebooks.get(i).setDefaultNotebook(false);\r
+ conn.getNotebookTable().syncLinkedNotebook(notebooks.get(i), false, readOnly); \r
+ } catch (EDAMUserException e) {\r
+ readOnly = true;\r
+ e.printStackTrace();\r
+ } catch (EDAMNotFoundException e) {\r
+ readOnly = true;\r
+ e.printStackTrace();\r
+ } catch (EDAMSystemException e) {\r
+ readOnly = true;\r
+ e.printStackTrace();\r
+ } catch (TException e) {\r
+ readOnly = true;\r
+ e.printStackTrace();\r
+ }\r
+\r
+ }\r
+ } \r
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteNotebooks");\r
+ }\r
+\r
+ private void findNewLinkedTags(Client noteStore, List<Note> newNotes, String token) {\r
+ if (newNotes == null)\r
+ return;\r
+ for (int i=0; i<newNotes.size(); i++) {\r
+ Note n = newNotes.get(i);\r
+ for (int j=0; j<n.getTagGuidsSize(); j++) {\r
+ String tag = n.getTagGuids().get(j);\r
+ if (!conn.getTagTable().exists(tag)) {\r
+ Tag newTag;\r
+ try {\r
+ newTag = noteStore.getTag(token, tag);\r
+ conn.getTagTable().addTag(newTag, false);\r
+ } catch (EDAMUserException e) {\r
+ e.printStackTrace();\r
+ } catch (EDAMSystemException e) {\r
+ e.printStackTrace();\r
+ } catch (EDAMNotFoundException e) {\r
+ e.printStackTrace();\r
+ } catch (TException e) {\r
+ e.printStackTrace();\r
+ }\r
+ \r
+ }\r
+ }\r
+ }\r
+ }\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
