/*\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.sql;\r
\r
+import java.text.DateFormat;\r
+import java.text.ParseException;\r
+import java.text.SimpleDateFormat;\r
+import java.util.ArrayList;\r
+import java.util.HashMap;\r
import java.util.List;\r
\r
+import org.apache.commons.lang3.StringEscapeUtils;\r
+\r
import com.evernote.edam.type.Note;\r
+import com.evernote.edam.type.NoteAttributes;\r
+import com.evernote.edam.type.Resource;\r
+import com.evernote.edam.type.Tag;\r
import com.trolltech.qt.core.QByteArray;\r
import com.trolltech.qt.core.QDateTime;\r
+import com.trolltech.qt.core.QTextCodec;\r
+import com.trolltech.qt.gui.QPixmap;\r
\r
import cx.fbn.nevernote.Global;\r
-import cx.fbn.nevernote.sql.requests.NoteRequest;\r
+import cx.fbn.nevernote.evernote.EnmlConverter;\r
+import cx.fbn.nevernote.evernote.NoteMetadata;\r
+import cx.fbn.nevernote.sql.driver.NSqlQuery;\r
+import cx.fbn.nevernote.utilities.ApplicationLogger;\r
import cx.fbn.nevernote.utilities.Pair;\r
\r
public class NoteTable {\r
+ private final ApplicationLogger logger;\r
+ public final NoteTagsTable noteTagsTable;\r
public NoteResourceTable noteResourceTable;\r
- public NoteTagsTable noteTagsTable;\r
- \r
+ private final DatabaseConnection db;\r
int id;\r
+\r
+ // Prepared Queries to improve speed\r
+ private NSqlQuery getQueryWithContent;\r
+ private NSqlQuery getQueryWithoutContent;\r
+ private NSqlQuery getAllQueryWithoutContent;\r
\r
// Constructor\r
- public NoteTable(int i) {\r
- id = i;\r
- noteTagsTable = new NoteTagsTable(id);\r
- noteResourceTable = new NoteResourceTable(id);\r
+ public NoteTable(ApplicationLogger l, DatabaseConnection d) {\r
+ logger = l;\r
+ db = d;\r
+ id = 0;\r
+ noteResourceTable = new NoteResourceTable(logger, db);\r
+ noteTagsTable = new NoteTagsTable(logger, db);\r
+ getQueryWithContent = null;\r
+ getQueryWithoutContent = null;\r
}\r
// Create the table\r
public void createTable() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Create_Table;\r
- Global.dbRunner.addWork(request);\r
+ //getQueryWithContent = new NSqlQuery(db.getConnection());\r
+ //getQueryWithoutContent = new NSqlQuery(db.getConnection());\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ logger.log(logger.HIGH, "Creating table Note...");\r
+ if (!query.exec("Create table Note (guid varchar primary key, " +\r
+ "updateSequenceNumber integer, title varchar, content varchar, contentHash varchar, "+\r
+ "contentLength integer, created timestamp, updated timestamp, deleted timestamp, " \r
+ +"active integer, notebookGuid varchar, attributeSubjectDate timestamp, "+\r
+ "attributeLatitude double, attributeLongitude double, attributeAltitude double,"+\r
+ "attributeAuthor varchar, attributeSource varchar, attributeSourceUrl varchar, "+\r
+ "attributeSourceApplication varchar, indexNeeded boolean, isExpunged boolean, " +\r
+ "isDirty boolean)")) \r
+ logger.log(logger.HIGH, "Table Note creation FAILED!!!"); \r
+ if (!query.exec("CREATE INDEX unindexed_notess on note (indexneeded desc, guid);"))\r
+ logger.log(logger.HIGH, "Note unindexed_notes index creation FAILED!!!");\r
+ if (!query.exec("CREATE INDEX unsynchronized_notes on note (isDirty desc, guid);"))\r
+ logger.log(logger.HIGH, "note unsynchronized_notes index creation FAILED!!!"); \r
+ noteTagsTable.createTable();\r
+// noteResourceTable.createTable(); \r
}\r
// Drop the table\r
public void dropTable() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Drop_Table;\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.exec("Drop table Note");\r
+ noteTagsTable.dropTable();\r
+ noteResourceTable.dropTable();\r
}\r
// Save Note List from Evernote \r
public void addNote(Note n, boolean isDirty) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.note = n.deepCopy();\r
- request.bool1 = isDirty;\r
- request.type = NoteRequest.Add_Note;\r
- Global.dbRunner.addWork(request);\r
+ logger.log(logger.EXTREME, "Inside addNote");\r
+ if (n == null)\r
+ return;\r
+ \r
+ SimpleDateFormat simple = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");\r
+\r
+ NSqlQuery query = new NSqlQuery(db.getConnection()); \r
+ query.prepare("Insert Into Note ("\r
+ +"guid, updateSequenceNumber, title, content, "\r
+ +"contentHash, contentLength, created, updated, deleted, active, notebookGuid, "\r
+ +"attributeSubjectDate, attributeLatitude, attributeLongitude, attributeAltitude, "\r
+ +"attributeAuthor, attributeSource, attributeSourceUrl, attributeSourceApplication, "\r
+ +"indexNeeded, isExpunged, isDirty, titlecolor, thumbnailneeded" \r
+ +") Values("\r
+ +":guid, :updateSequenceNumber, :title, :content, "\r
+ +":contentHash, :contentLength, :created, :updated, :deleted, :active, :notebookGuid, "\r
+ +":attributeSubjectDate, :attributeLatitude, :attributeLongitude, :attributeAltitude, "\r
+ +":attributeAuthor, :attributeSource, :attributeSourceUrl, :attributeSourceApplication, "\r
+ +":indexNeeded, :isExpunged, :isDirty, -1, true) ");\r
+\r
+ StringBuilder created = new StringBuilder(simple.format(n.getCreated())); \r
+ StringBuilder updated = new StringBuilder(simple.format(n.getUpdated())); \r
+ StringBuilder deleted = new StringBuilder(simple.format(n.getDeleted()));\r
+\r
+ \r
+ \r
+ query.bindValue(":guid", n.getGuid());\r
+ query.bindValue(":updateSequenceNumber", n.getUpdateSequenceNum());\r
+ query.bindValue(":title", n.getTitle());\r
+ if (isDirty) {\r
+ EnmlConverter enml = new EnmlConverter(logger);\r
+ query.bindValue(":content", enml.fixEnXMLCrap(enml.fixEnMediaCrap(n.getContent())));\r
+ }\r
+ else\r
+ query.bindValue(":content", n.getContent());\r
+ query.bindValue(":contentHash", n.getContentHash());\r
+ query.bindValue(":contentLength", n.getContentLength());\r
+ query.bindValue(":created", created.toString());\r
+ query.bindValue(":updated", updated.toString());\r
+ query.bindValue(":deleted", deleted.toString());\r
+ query.bindValue(":active", n.isActive());\r
+ query.bindValue(":notebookGuid", n.getNotebookGuid());\r
+ \r
+ if (n.getAttributes() != null) {\r
+ created = new StringBuilder(simple.format(n.getAttributes().getSubjectDate()));\r
+ query.bindValue(":attributeSubjectDate", created.toString());\r
+ query.bindValue(":attributeLatitude", n.getAttributes().getLatitude());\r
+ query.bindValue(":attributeLongitude", n.getAttributes().getLongitude());\r
+ query.bindValue(":attributeAltitude", n.getAttributes().getAltitude());\r
+ query.bindValue(":attributeAuthor", n.getAttributes().getAuthor());\r
+ query.bindValue(":attributeSource", n.getAttributes().getSource());\r
+ query.bindValue(":attributeSourceUrl", n.getAttributes().getSourceURL());\r
+ query.bindValue(":attributeSourceApplication", n.getAttributes().getSourceApplication());\r
+ } else {\r
+ created = new StringBuilder(simple.format(n.getCreated())); \r
+ query.bindValue(":attributeSubjectDate", created.toString());\r
+ query.bindValue(":attributeLatitude", 0.0);\r
+ query.bindValue(":attributeLongitude", 0.0);\r
+ query.bindValue(":attributeAltitude", 0.0);\r
+ query.bindValue(":attributeAuthor", "");\r
+ query.bindValue(":attributeSource", "");\r
+ query.bindValue(":attributeSourceUrl", "");\r
+ query.bindValue(":attributeSourceApplication", "");\r
+ }\r
+ query.bindValue(":indexNeeded", true);\r
+ query.bindValue(":isExpunged", false);\r
+ query.bindValue(":isDirty", isDirty);\r
+\r
+ \r
+ if (!query.exec())\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ \r
+ // Save the note tags\r
+ if (n.getTagGuids() != null) {\r
+ for (int i=0; i<n.getTagGuids().size(); i++) \r
+ noteTagsTable.saveNoteTag(n.getGuid(), n.getTagGuids().get(i));\r
+ }\r
+ logger.log(logger.EXTREME, "Leaving addNote");\r
} \r
+ // Setup queries for get to save time later\r
+ private void prepareQueries() {\r
+ if (getQueryWithContent == null) {\r
+ getQueryWithContent = new NSqlQuery(db.getConnection());\r
+ if (!getQueryWithContent.prepare("Select "\r
+ +"guid, updateSequenceNumber, title, "\r
+ +"created, updated, deleted, active, notebookGuid, "\r
+ +"attributeSubjectDate, attributeLatitude, attributeLongitude, attributeAltitude, "\r
+ +"attributeAuthor, attributeSource, attributeSourceUrl, attributeSourceApplication, "\r
+ +"attributeContentClass, "\r
+ +"content, contentHash, contentLength"\r
+ +" from Note where guid=:guid and isExpunged=false")) {\r
+ logger.log(logger.EXTREME, "Note SQL select prepare with content has failed.");\r
+ logger.log(logger.MEDIUM, getQueryWithContent.lastError());\r
+ }\r
+ }\r
+ \r
+ if (getQueryWithoutContent == null) {\r
+ getQueryWithoutContent = new NSqlQuery(db.getConnection());\r
+ if (!getQueryWithoutContent.prepare("Select "\r
+ +"guid, updateSequenceNumber, title, "\r
+ +"created, updated, deleted, active, notebookGuid, "\r
+ +"attributeSubjectDate, attributeLatitude, attributeLongitude, attributeAltitude, "\r
+ +"attributeAuthor, attributeSource, attributeSourceUrl, attributeSourceApplication, "\r
+ +"attributeContentClass"\r
+ +" from Note where guid=:guid and isExpunged=false")) {\r
+ logger.log(logger.EXTREME, "Note SQL select prepare without content has failed.");\r
+ logger.log(logger.MEDIUM, getQueryWithoutContent.lastError());\r
+ }\r
+ }\r
+ \r
+ if (getAllQueryWithoutContent == null) {\r
+ getAllQueryWithoutContent = new NSqlQuery(db.getConnection());\r
+ \r
+ if (!getAllQueryWithoutContent.prepare("Select "\r
+ +"guid, updateSequenceNumber, title, "\r
+ +"created, updated, deleted, active, notebookGuid, "\r
+ +"attributeSubjectDate, attributeLatitude, attributeLongitude, attributeAltitude, "\r
+ +"attributeAuthor, attributeSource, attributeSourceUrl, attributeSourceApplication, "\r
+ +"attributeContentClass "\r
+ +" from Note where isExpunged = false")) {\r
+ logger.log(logger.EXTREME, "Note SQL select prepare without content has failed.");\r
+ logger.log(logger.MEDIUM, getQueryWithoutContent.lastError());\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ // Get a note's content in blob format for index.\r
+ public String getNoteContentNoUTFConversion(String guid) {\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Select content from note where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ query.exec(); \r
+ query.next();\r
+ return query.valueString(0);\r
+ }\r
// Get a note by Guid\r
public Note getNote(String noteGuid, boolean loadContent, boolean loadResources, boolean loadRecognition, boolean loadBinary, boolean loadTags) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Note;\r
- request.string1 = new String(noteGuid);\r
- request.bool1 = loadContent;\r
- request.bool2 = loadResources;\r
- request.bool3 = loadRecognition;\r
- request.bool4 = loadBinary;\r
- request.bool5 = loadTags;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseNote;\r
+\r
+// extractMetadata("otherKey:{values};baumgarte:{titleColor=fff;pinned=true;};finalKey:{values1);");\r
+ if (noteGuid == null)\r
+ return null;\r
+ if (noteGuid.trim().equals(""))\r
+ return null;\r
+\r
+ prepareQueries();\r
+ NSqlQuery query;\r
+ if (loadContent) {\r
+ query = getQueryWithContent;\r
+ } else {\r
+ query = getQueryWithoutContent;\r
+ }\r
+ \r
+ query.bindValue(":guid", noteGuid);\r
+ if (!query.exec()) {\r
+ logger.log(logger.EXTREME, "Note SQL select exec has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ return null;\r
+ }\r
+ if (!query.next()) {\r
+ logger.log(logger.EXTREME, "SQL Retrieve failed for note guid " +noteGuid + " in getNote()");\r
+ logger.log(logger.EXTREME, " -> " +query.lastError().toString());\r
+ logger.log(logger.EXTREME, " -> " +query.lastError());\r
+ return null;\r
+ }\r
+ Note n = mapNoteFromQuery(query, loadContent, loadResources, loadRecognition, loadBinary, loadTags);\r
+ n.setContent(fixCarriageReturn(n.getContent()));\r
+ n.getAttributes().setContentClassIsSet(false);\r
+ return n;\r
+ }\r
+ // Get a note by Guid\r
+ public Note mapNoteFromQuery(NSqlQuery query, boolean loadContent, boolean loadResources, boolean loadRecognition, boolean loadBinary, boolean loadTags) {\r
+ DateFormat indfm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");\r
+// indfm = new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy");\r
+\r
+ Note n = new Note();\r
+ NoteAttributes na = new NoteAttributes();\r
+ n.setAttributes(na);\r
+ \r
+ n.setGuid(query.valueString(0));\r
+ n.setUpdateSequenceNum(new Integer(query.valueString(1)));\r
+ n.setTitle(query.valueString(2));\r
+\r
+ try {\r
+ n.setCreated(indfm.parse(query.valueString(3)).getTime());\r
+ n.setUpdated(indfm.parse(query.valueString(4)).getTime());\r
+ n.setDeleted(indfm.parse(query.valueString(5)).getTime());\r
+ } catch (ParseException e) {\r
+ e.printStackTrace();\r
+ }\r
+\r
+ n.setActive(query.valueBoolean(6,true));\r
+ n.setNotebookGuid(query.valueString(7));\r
+ \r
+ try {\r
+ String attributeSubjectDate = query.valueString(8);\r
+ if (!attributeSubjectDate.equals(""))\r
+ na.setSubjectDate(indfm.parse(attributeSubjectDate).getTime());\r
+ } catch (ParseException e) {\r
+ e.printStackTrace();\r
+ }\r
+ na.setLatitude(new Float(query.valueString(9)));\r
+ na.setLongitude(new Float(query.valueString(10)));\r
+ na.setAltitude(new Float(query.valueString(11)));\r
+ na.setAuthor(query.valueString(12));\r
+ na.setSource(query.valueString(13));\r
+ na.setSourceURL(query.valueString(14));\r
+ na.setSourceApplication(query.valueString(15));\r
+ na.setContentClass(query.valueString(16));\r
+ \r
+ if (loadTags) {\r
+ List<String> tagGuids = noteTagsTable.getNoteTags(n.getGuid());\r
+ List<String> tagNames = new ArrayList<String>();\r
+ TagTable tagTable = db.getTagTable();\r
+ for (int i=0; i<tagGuids.size(); i++) {\r
+ String currentGuid = tagGuids.get(i);\r
+ Tag tag = tagTable.getTag(currentGuid);\r
+ if (tag.getName() != null)\r
+ tagNames.add(tag.getName());\r
+ else\r
+ tagNames.add("");\r
+ }\r
+\r
+ n.setTagNames(tagNames);\r
+ n.setTagGuids(tagGuids); \r
+ }\r
+ \r
+ if (loadContent) {\r
+ QTextCodec codec = QTextCodec.codecForLocale();\r
+ codec = QTextCodec.codecForName("UTF-8");\r
+ String unicode = codec.fromUnicode(query.valueString(17)).toString();\r
+\r
+ // This is a hack. Basically I need to convert HTML Entities to "normal" text, but if I\r
+ // convert the < character to < it will mess up the XML parsing. So, to get around this\r
+ // I am "bit stuffing" the < to &< so StringEscapeUtils doesn't unescape it. After\r
+ // I'm done I convert it back.\r
+ StringBuffer buffer = new StringBuffer(unicode);\r
+ if (Global.enableHTMLEntitiesFix && unicode.indexOf("&#") > 0) {\r
+ unicode = query.valueString(17);\r
+ //System.out.println(unicode);\r
+ //unicode = unicode.replace("<", "&_lt;");\r
+ //unicode = codec.fromUnicode(StringEscapeUtils.unescapeHtml(unicode)).toString();\r
+ //unicode = unicode.replace("&_lt;", "<");\r
+ //System.out.println("************************");\r
+ int j=1;\r
+ for (int i=buffer.indexOf("&#"); i != -1 && buffer.indexOf("&#", i)>0; i=buffer.indexOf("&#",i+1)) {\r
+ j = buffer.indexOf(";",i)+1;\r
+ if (i<j) {\r
+ String entity = buffer.substring(i,j).toString();\r
+ int len = entity.length()-1;\r
+ String tempEntity = entity.substring(2, len);\r
+ try {\r
+ Integer.parseInt(tempEntity);\r
+ entity = codec.fromUnicode(StringEscapeUtils.unescapeHtml4(entity)).toString();\r
+ buffer.delete(i, j);\r
+ buffer.insert(i, entity);\r
+ } catch (Exception e){ }\r
+ \r
+ }\r
+ } \r
+ } \r
+ \r
+ n.setContent(unicode);\r
+// n.setContent(query.valueString(16).toString());\r
+ \r
+ String contentHash = query.valueString(18);\r
+ if (contentHash != null)\r
+ n.setContentHash(contentHash.getBytes());\r
+ n.setContentLength(new Integer(query.valueString(19)));\r
+ }\r
+ if (loadResources)\r
+ n.setResources(noteResourceTable.getNoteResources(n.getGuid(), loadBinary));\r
+ if (loadRecognition) {\r
+ if (n.getResources() == null) {\r
+ List<Resource> resources = noteResourceTable.getNoteResourcesRecognition(n.getGuid());\r
+ n.setResources(resources);\r
+ } else {\r
+ // We need to merge the recognition resources with the note resources retrieved earlier\r
+ for (int i=0; i<n.getResources().size(); i++) {\r
+ Resource r = noteResourceTable.getNoteResourceRecognition(n.getResources().get(i).getGuid());\r
+ n.getResources().get(i).setRecognition(r.getRecognition());\r
+ }\r
+ }\r
+ }\r
+ n.setContent(fixCarriageReturn(n.getContent()));\r
+ return n;\r
}\r
// Update a note's title\r
public void updateNoteTitle(String guid, String title) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Title;\r
- request.string1 = new String(guid);\r
- request.string2 = new String(title);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set title=:title, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note title sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ query.bindValue(":title", title);\r
+ query.bindValue(":guid", guid);\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note title has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
}\r
// Update a note's creation date\r
public void updateNoteCreatedDate(String guid, QDateTime date) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Creation_Date;\r
- request.string1 = new String(guid);\r
- request.date = new QDateTime(date);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set created=:created, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note creation update sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
+ query.bindValue(":created", date.toString("yyyy-MM-dd HH:mm:ss"));\r
+ query.bindValue(":guid", guid);\r
+ \r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note creation date has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
}\r
// Update a note's creation date\r
public void updateNoteAlteredDate(String guid, QDateTime date) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Altered_Date;\r
- request.string1 = new String(guid);\r
- request.date = new QDateTime(date);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set updated=:altered, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note altered sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
+ query.bindValue(":altered", date.toString("yyyy-MM-dd HH:mm:ss"));\r
+ query.bindValue(":guid", guid);\r
+ \r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note altered date has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
}\r
// Update a note's creation date\r
public void updateNoteSubjectDate(String guid, QDateTime date) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Subject_Date;\r
- request.string1 = new String(guid);\r
- request.date = new QDateTime(date);\r
- Global.dbRunner.addWork(request);\r
- }\r
- // Update a note's author\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set attributeSubjectDate=:altered, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note subject date sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
+ query.bindValue(":altered", date.toString("yyyy-MM-dd HH:mm:ss"));\r
+ query.bindValue(":guid", guid);\r
+ \r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note subject date date has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ }\r
+ // Update a note's creation date\r
public void updateNoteAuthor(String guid, String author) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Author;\r
- request.string1 = new String(guid);\r
- request.string2 = new String(author);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set attributeAuthor=:author, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note author sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+\r
+ query.bindValue(":author", author);\r
+ query.bindValue(":guid", guid);\r
+\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note author has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
+ }\r
+ // Update a note's geo tags\r
+ public void updateNoteGeoTags(String guid, Double lon, Double lat, Double alt) {\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set attributeLongitude=:longitude, "+\r
+ "attributeLatitude=:latitude, attributeAltitude=:altitude, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note author sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+\r
+ query.bindValue(":longitude", lon);\r
+ query.bindValue(":latitude", lat);\r
+ query.bindValue(":altitude", alt);\r
+ query.bindValue(":guid", guid);\r
+\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note geo tag has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
}\r
// Update a note's creation date\r
public void updateNoteSourceUrl(String guid, String url) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Source_Url;\r
- request.string1 = new String(guid);\r
- request.string2 = new String(url);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set attributeSourceUrl=:url, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note url sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
+ query.bindValue(":url", url);\r
+ query.bindValue(":guid", guid);\r
+\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note url has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
}\r
// Update the notebook that a note is assigned to\r
public void updateNoteNotebook(String guid, String notebookGuid, boolean expungeFromRemote) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Notebook;\r
- request.string1 = new String(guid);\r
- request.string2 = new String(notebookGuid);\r
- request.bool1 = expungeFromRemote;\r
- Global.dbRunner.addWork(request);\r
- }\r
- // Update a note's content\r
+ String currentNotebookGuid = new String("");\r
+ \r
+ \r
+ // If we are going from a synchronized notebook to a local notebook, we\r
+ // need to tell Evernote to purge the note online. However, if this is \r
+ // conflicting change we move it to the local notebook without deleting it \r
+ // or it would then delete the copy on the remote server.\r
+ NotebookTable notebookTable = new NotebookTable(logger, db);\r
+ DeletedTable deletedTable = new DeletedTable(logger, db);\r
+ if (expungeFromRemote) {\r
+ if (!notebookTable.isNotebookLocal(currentNotebookGuid) & notebookTable.isNotebookLocal(notebookGuid)) {\r
+ deletedTable.addDeletedItem(guid, "NOTE");\r
+ }\r
+ }\r
+ \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set notebookGuid=:notebook, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note notebook sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ query.bindValue(":notebook", notebookGuid);\r
+ query.bindValue(":guid", guid);\r
+ \r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note notebook has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ };\r
+ }\r
+ // Update a note's title\r
public void updateNoteContent(String guid, String content) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Content;\r
- request.string1 = new String(guid);\r
- request.string2 = new String(content);\r
- Global.dbRunner.addWork(request);\r
- }\r
- // Get a note's contents as a binary string (useful for unicode on sync)\r
- public String getNoteContentBinary(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Note_Content_Binary;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseString;\r
- }\r
- // Check a note to see if it passes the attribute selection criteria\r
- public boolean checkAttributeSelection(Note n) {\r
- if (Global.createdSinceFilter.check(n) &&\r
- Global.createdBeforeFilter.check(n) && \r
- Global.changedSinceFilter.check(n) &&\r
- Global.changedBeforeFilter.check(n) &&\r
- Global.containsFilter.check(this, n))\r
- return true;\r
- \r
- return false;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set content=:content, updated=CURRENT_TIMESTAMP(), isDirty=true, indexNeeded=true, " +\r
+ " thumbnailneeded=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note content sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
+// QTextCodec codec = QTextCodec.codecForLocale();\r
+// codec = QTextCodec.codecForName("UTF-8");\r
+// query.bindValue(":content", codec.fromUnicode(content).toString());\r
+ query.bindValue(":content", content);\r
+ query.bindValue(":guid", guid);\r
+\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note content has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
}\r
+\r
// Delete a note\r
public void deleteNote(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Delete_Note;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Update Note set deleted=CURRENT_TIMESTAMP(), active=false, isDirty=true where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ if (!query.exec()) {\r
+ logger.log(logger.MEDIUM, "Note delete failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
}\r
public void restoreNote(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Restore_Note;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Update Note set deleted=:reset, active=true, isDirty=true where guid=:guid");\r
+// query.prepare("Update Note set deleted=0, active=true, isDirty=true where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ query.bindValue(":reset", "1969-12-31 19:00:00");\r
+ if (!query.exec()) {\r
+ logger.log(logger.MEDIUM, "Note restore failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
}\r
// Purge a note (actually delete it instead of just marking it deleted)\r
public void expungeNote(String guid, boolean permanentExpunge, boolean needsSync) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Expunge_Note;\r
- request.string1 = new String(guid);\r
- request.bool1 = permanentExpunge;\r
- request.bool2 = needsSync;\r
- Global.dbRunner.addWork(request);\r
+ \r
+ if (!permanentExpunge) {\r
+ hideExpungedNote(guid, needsSync);\r
+ return;\r
+ }\r
+ \r
+ \r
+ NSqlQuery note = new NSqlQuery(db.getConnection());\r
+ NSqlQuery resources = new NSqlQuery(db.getResourceConnection());\r
+ NSqlQuery tags = new NSqlQuery(db.getConnection());\r
+ NSqlQuery words = new NSqlQuery(db.getIndexConnection());\r
+ \r
+ note.prepare("Delete from Note where guid=:guid");\r
+ resources.prepare("Delete from NoteResources where noteGuid=:guid");\r
+ tags.prepare("Delete from NoteTags where noteGuid=:guid");\r
+ words.prepare("Delete from words where guid=:guid");\r
+\r
+ note.bindValue(":guid", guid);\r
+ resources.bindValue(":guid", guid);\r
+ tags.bindValue(":guid", guid);\r
+ words.bindValue(":guid", guid);\r
+ \r
+ // Start purging notes.\r
+ if (!note.exec()) {\r
+ logger.log(logger.MEDIUM, "Purge from note failed.");\r
+ logger.log(logger.MEDIUM, note.lastError());\r
+ }\r
+ if (!resources.exec()) {\r
+ logger.log(logger.MEDIUM, "Purge from resources failed.");\r
+ logger.log(logger.MEDIUM, resources.lastError());\r
+ }\r
+ if (!tags.exec()) {\r
+ logger.log(logger.MEDIUM, "Note tags delete failed.");\r
+ logger.log(logger.MEDIUM, tags.lastError());\r
+ }\r
+\r
+ if (!words.exec()) {\r
+ logger.log(logger.MEDIUM, "Word delete failed.");\r
+ logger.log(logger.MEDIUM, words.lastError());\r
+ }\r
+ if (needsSync) {\r
+ DeletedTable deletedTable = new DeletedTable(logger, db);\r
+ deletedTable.addDeletedItem(guid, "Note");\r
+ }\r
+\r
+ }\r
+ // Purge a bunch of notes based upon the notebook\r
+ public void expungeNotesByNotebook(String notebookGuid, boolean permanentExpunge, boolean needsSync) {\r
+ List<String> notes = getNotesByNotebook(notebookGuid);\r
+ for (int i=0; i<notes.size(); i++) {\r
+ expungeNote(notes.get(i), permanentExpunge, needsSync);\r
+ }\r
+ }\r
+\r
+ // Purge a note (actually delete it instead of just marking it deleted)\r
+ public void hideExpungedNote(String guid, boolean needsSync) {\r
+ NSqlQuery note = new NSqlQuery(db.getConnection());\r
+ NSqlQuery resources = new NSqlQuery(db.getResourceConnection());\r
+ NSqlQuery tags = new NSqlQuery(db.getConnection());\r
+ NSqlQuery words = new NSqlQuery(db.getIndexConnection());\r
+ \r
+ note.prepare("Update Note set isExpunged=true where guid=:guid");\r
+ resources.prepare("Delete from NoteResources where noteGuid=:guid");\r
+ tags.prepare("Delete from NoteTags where noteGuid=:guid");\r
+// words.prepare("Delete from words where guid=:guid");\r
+\r
+ note.bindValue(":guid", guid);\r
+ resources.bindValue(":guid", guid);\r
+ tags.bindValue(":guid", guid);\r
+ words.bindValue(":guid", guid);\r
+\r
+ // Start purging notes.\r
+ if (!note.exec()) {\r
+ logger.log(logger.MEDIUM, "Purge from note failed.");\r
+ logger.log(logger.MEDIUM, note.lastError());\r
+ }\r
+ if (!resources.exec()) {\r
+ logger.log(logger.MEDIUM, "Purge from resources failed.");\r
+ logger.log(logger.MEDIUM, resources.lastError());\r
+ }\r
+ if (!tags.exec()) {\r
+ logger.log(logger.MEDIUM, "Note tags delete failed.");\r
+ logger.log(logger.MEDIUM, tags.lastError());\r
+ }\r
+// System.out.println("Hiding Note: Deleting words");\r
+// if (!words.exec()) {\r
+// logger.log(logger.MEDIUM, "Word delete failed.");\r
+// logger.log(logger.MEDIUM, words.lastError());\r
+// }\r
+ if (needsSync) {\r
+ DeletedTable deletedTable = new DeletedTable(logger, db);\r
+ deletedTable.addDeletedItem(guid, "Note");\r
+ }\r
}\r
+\r
+ \r
// Purge all deleted notes;\r
public void expungeAllDeletedNotes() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Expunge_All_Deleted_Notes;\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.exec("select guid, updateSequenceNumber from note where active = false");\r
+ List<String> guids = new ArrayList<String>();\r
+ List<Integer> usns = new ArrayList<Integer>();\r
+ while (query.next()) {\r
+ guids.add(query.valueString(0));\r
+ Integer usn = new Integer(query.valueString(1));\r
+ usns.add(usn);\r
+ }\r
+ \r
+ for (int i=0; i<guids.size(); i++) {\r
+ Integer usn = usns.get(i);\r
+ String guid = guids.get(i);\r
+ if (usn == 0)\r
+ expungeNote(guid, true, false);\r
+ else\r
+ expungeNote(guid, false, true);\r
+ }\r
}\r
// Update the note sequence number\r
public void updateNoteSequence(String guid, int sequence) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Sequence;\r
- request.string1 = new String(guid);\r
- request.int1 = sequence;\r
- Global.dbRunner.addWork(request);\r
+ boolean check;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ check = query.prepare("Update Note set updateSequenceNumber=:sequence where guid=:guid");\r
+\r
+ query.bindValue(":sequence", sequence);\r
+ query.bindValue(":guid", guid);\r
+ \r
+ query.exec();\r
+ if (!check) {\r
+ logger.log(logger.MEDIUM, "Note sequence update failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ } \r
}\r
// Update the note Guid\r
public void updateNoteGuid(String oldGuid, String newGuid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note_Guid;\r
- request.string1 = new String(oldGuid);\r
- request.string2 = new String(newGuid);\r
- Global.dbRunner.addWork(request);\r
+ boolean check;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ NSqlQuery resQuery = new NSqlQuery(db.getResourceConnection());\r
+ NSqlQuery wordQuery = new NSqlQuery(db.getIndexConnection());\r
+ query.prepare("Update Note set guid=:newGuid, original_guid=:original_guid where guid=:oldGuid");\r
+\r
+ query.bindValue(":original_guid", oldGuid);\r
+ query.bindValue(":newGuid", newGuid);\r
+ query.bindValue(":oldGuid", oldGuid);\r
+\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.MEDIUM, "Note Guid update failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ } \r
+ \r
+ query.prepare("Update NoteTags set noteGuid=:newGuid where noteGuid=:oldGuid");\r
+ query.bindValue(":newGuid", newGuid);\r
+ query.bindValue(":oldGuid", oldGuid);\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.MEDIUM, "Note guid update failed for NoteTags.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ \r
+ wordQuery.prepare("Update words set guid=:newGuid where guid=:oldGuid");\r
+ wordQuery.bindValue(":newGuid", newGuid);\r
+ wordQuery.bindValue(":oldGuid", oldGuid);\r
+ wordQuery.exec();\r
+ if (!check) {\r
+ logger.log(logger.MEDIUM, "Note guid update failed for Words.");\r
+ logger.log(logger.MEDIUM, wordQuery.lastError());\r
+ }\r
+ resQuery.prepare("Update noteresources set noteguid=:newGuid where noteguid=:oldGuid");\r
+ resQuery.bindValue(":newGuid", newGuid);\r
+ resQuery.bindValue(":oldGuid", oldGuid);\r
+ resQuery.exec();\r
+ if (!check) {\r
+ logger.log(logger.MEDIUM, "Note guid update failed for noteresources.");\r
+ logger.log(logger.MEDIUM, resQuery.lastError());\r
+ }\r
}\r
// Update a note\r
- public void updateNote(Note n, boolean isNew) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Note;\r
- request.note = n.deepCopy();\r
- request.bool1 = isNew;\r
- Global.dbRunner.addWork(request);\r
+ public void updateNote(Note n) {\r
+ NoteMetadata meta = getNoteMetaInformation(n.getGuid());\r
+ String originalGuid = findAlternateGuid(n.getGuid());\r
+ expungeNote(n.getGuid(), true, false);\r
+ addNote(n, false);\r
+ if (n!=null) {\r
+ updateNoteMetadata(meta);\r
+ }\r
+ if (originalGuid != null) {\r
+ updateNoteGuid(n.getGuid(), originalGuid);\r
+ updateNoteGuid(originalGuid, n.getGuid());\r
+ }\r
}\r
// Does a note exist?\r
public boolean exists(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Exists;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseBoolean;\r
- }\r
- // This is a convience method to check if a tag exists & update/create based upon it\r
- public void syncNote(Note note, boolean isDirty) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Sync_Note;\r
- request.note = note.deepCopy();\r
- request.bool1 = isDirty;\r
- Global.dbRunner.addWork(request);\r
+ if (guid == null)\r
+ return false;\r
+ if (guid.trim().equals(""))\r
+ return false;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Select guid from note where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ if (!query.exec())\r
+ logger.log(logger.EXTREME, "note.exists SQL retrieve has failed.");\r
+ boolean retVal = query.next();\r
+ return retVal;\r
+ }\r
+ // Does a note exist?\r
+ public boolean isNoteExpunged(String guid) {\r
+ if (guid == null)\r
+ return false;\r
+ if (guid.trim().equals(""))\r
+ return false;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Select isExpunged from note where guid=:guid and isExpunged = true");\r
+ query.bindValue(":guid", guid);\r
+ if (!query.exec())\r
+ logger.log(logger.EXTREME, "note.isNoteExpunged SQL retrieve has failed.");\r
+ boolean retVal = query.next();\r
+ return retVal;\r
+ }\r
+ // This is a convience method to check if a note exists & update/create based upon it\r
+ public void syncNote(Note note) {\r
+ // If we got the note from Evernote we use its \r
+ // metadata instead of the local copy.\r
+ NoteMetadata meta = null;\r
+ if (note.getAttributes() != null && note.getAttributes().getSourceApplication() != null) {\r
+ meta = extractMetadata(note.getAttributes().getSourceApplication());\r
+ } else \r
+ meta = getNoteMetaInformation(note.getGuid());\r
+ \r
+ // Now, if the note exists we simply update it. Otherwise we\r
+ // add a new note.\r
+ if (exists(note.getGuid())) {\r
+ updateNote(note);\r
+ }\r
+ else\r
+ addNote(note, false);\r
+ \r
+ // If we have metadata, we write it out.\r
+ if (meta != null) {\r
+ meta.setGuid(note.getGuid());\r
+ updateNoteMetadata(meta);\r
+ }\r
}\r
// Get a list of notes that need to be updated\r
public List <Note> getDirty() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Dirty;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseNotes;\r
+ String guid;\r
+ Note tempNote;\r
+ List<Note> notes = new ArrayList<Note>();\r
+ List<String> index = new ArrayList<String>();\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.exec("Select guid from Note where isDirty = true and isExpunged = false and notebookGuid not in (select guid from notebook where local = true or linked = true)");\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed: " +query.lastError().toString());\r
+ \r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ guid = new String();\r
+ guid = query.valueString(0);\r
+ index.add(guid); \r
+ } \r
+ \r
+ // Start getting notes\r
+ for (int i=0; i<index.size(); i++) {\r
+ tempNote = getNote(index.get(i), true,true,false,true,true);\r
+ notes.add(tempNote);\r
+ }\r
+ return notes; \r
+ }\r
+ // Get a list of notes that need to be updated\r
+ public List <Note> getDirtyLinkedNotes() {\r
+ String guid;\r
+ Note tempNote;\r
+ List<Note> notes = new ArrayList<Note>();\r
+ List<String> index = new ArrayList<String>();\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.exec("Select guid from Note where isDirty = true and isExpunged = false and notebookGuid in (select guid from notebook where linked = true)");\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed: " +query.lastError().toString());\r
+ \r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ guid = new String();\r
+ guid = query.valueString(0);\r
+ index.add(guid); \r
+ } \r
+ \r
+ // Start getting notes\r
+ for (int i=0; i<index.size(); i++) {\r
+ tempNote = getNote(index.get(i), true,true,false,true,true);\r
+ notes.add(tempNote);\r
+ }\r
+ return notes; \r
+ }\r
+ // Get a list of notes that need to be updated\r
+ public List <Note> getDirtyLinked(String notebookGuid) {\r
+ String guid;\r
+ Note tempNote;\r
+ List<Note> notes = new ArrayList<Note>();\r
+ List<String> index = new ArrayList<String>();\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ query.prepare("Select guid from Note where isDirty = true and isExpunged = false and notebookGuid=:notebookGuid");\r
+ query.bindValue(":notebookGuid", notebookGuid);\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed getting dirty linked notes: " +query.lastError().toString());\r
+ \r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ guid = new String();\r
+ guid = query.valueString(0);\r
+ index.add(guid); \r
+ } \r
+ \r
+ // Start getting notes\r
+ for (int i=0; i<index.size(); i++) {\r
+ tempNote = getNote(index.get(i), true,true,false,true,true);\r
+ notes.add(tempNote);\r
+ }\r
+ return notes; \r
}\r
// Get a list of notes that need to be updated\r
- public List <String> getUnsynchronizedGUIDs() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Unsynchronized_Guids;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseStrings;\r
+ public List <String> getNotesByNotebook(String notebookGuid) {\r
+ List<String> notes = new ArrayList<String>();\r
+ List<String> index = new ArrayList<String>();\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("Select guid from Note where notebookguid=:notebookguid");\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed: " +query.lastError().toString());\r
+ query.bindValue(":notebookguid", notebookGuid);\r
+ query. exec();\r
+ \r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ index.add(query.valueString(0)); \r
+ } \r
+ \r
+ return notes; \r
}\r
+ // Get a list of notes that need to be updated\r
public boolean isNoteDirty(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Is_Note_Dirty;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseBoolean;\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("Select guid from Note where isDirty = true and guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed: " +query.lastError().toString());\r
+ \r
+ boolean returnValue;\r
+ // Get a list of the notes\r
+ if (query.next()) \r
+ returnValue = true; \r
+ else\r
+ returnValue = false;\r
+\r
+ return returnValue; \r
}\r
+\r
// Reset the dirty bit\r
public void resetDirtyFlag(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Reset_Dirty_Flag;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ query.prepare("Update note set isdirty=false where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ if (!query.exec())\r
+ logger.log(logger.EXTREME, "Error resetting note dirty field.");\r
}\r
// Get all notes\r
public List<String> getAllGuids() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_All_Guids;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseStrings;\r
+ List<String> notes = new ArrayList<String>();\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.exec("Select guid from Note");\r
+ if (!check)\r
+ logger.log(logger.EXTREME, "Notebook SQL retrieve has failed: "+query.lastError());\r
+\r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ notes.add(new String(query.valueString(0))); \r
+ }\r
+ return notes;\r
}\r
// Get all notes\r
public List<Note> getAllNotes() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_All_Notes;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseNotes;\r
+ List<Note> notes = new ArrayList<Note>();\r
+ prepareQueries();\r
+ boolean check; \r
+ if (getAllQueryWithoutContent == null) \r
+ prepareQueries();\r
+ NSqlQuery query = getAllQueryWithoutContent;\r
+ check = query.exec();\r
+ if (!check)\r
+ logger.log(logger.EXTREME, "Notebook SQL retrieve has failed: "+query.lastError());\r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ notes.add(mapNoteFromQuery(query, false, false, false, false, true));\r
+ }\r
+ return notes;\r
}\r
// Count unindexed notes\r
public int getUnindexedCount() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Unindexed_Count;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseInt;\r
- }\r
- // Count unsynchronized count\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.exec("select count(*) from note where indexneeded=true and isExpunged = false");\r
+ query.next(); \r
+ int returnValue = new Integer(query.valueString(0));\r
+ return returnValue;\r
+ }\r
+ // Count unsynchronized notes\r
public int getDirtyCount() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Dirty_Count;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseInt;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.exec("select count(guid) from note where isDirty=true and isExpunged = false");\r
+ query.next(); \r
+ int returnValue = new Integer(query.valueString(0));\r
+ return returnValue;\r
}\r
- // Count unindexed notes\r
+ // Count notes\r
public int getNoteCount() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Note_Count;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseInt;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.exec("select count(*) from note where isExpunged = false");\r
+ query.next(); \r
+ int returnValue = new Integer(query.valueString(0));\r
+ return returnValue;\r
}\r
// Count deleted notes\r
public int getDeletedCount() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Deleted_Count;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseInt;\r
- }\r
- // Reset a note's sequence count to zero. This is useful when moving a conflicting note\r
- public void resetSequenceNumber(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.string1 = new String(guid);\r
- request.type = NoteRequest.Reset_Note_Sequence;\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.exec("select count(*) from note where isExpunged = false and active = false");\r
+ if (!query.next()) \r
+ return 0;\r
+ int returnValue = new Integer(query.valueString(0));\r
+ return returnValue;\r
+ }\r
+ // Reset a note sequence number to zero. This is useful for moving conflicting notes\r
+ public void resetNoteSequence(String guid) {\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ boolean check = query.prepare("Update Note set updateSequenceNumber=0, isDirty=true where guid=:guid");\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note ResetSequence sql prepare has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
+ query.bindValue(":guid", guid);\r
+ check = query.exec();\r
+ if (!check) {\r
+ logger.log(logger.EXTREME, "Update note sequence number has failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ }\r
}\r
\r
+ \r
// Update a note resource by the hash\r
public void updateNoteResourceGuidbyHash(String noteGuid, String resGuid, String hash) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Resource_Guid_By_Hash;\r
- request.string1 = new String(noteGuid);\r
- request.string2 = new String(resGuid);\r
- request.string3 = new String(hash);\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getResourceConnection());\r
+/* query.prepare("Select guid from NoteResources where noteGuid=:noteGuid and datahash=:hex");\r
+ query.bindValue(":noteGuid", noteGuid);\r
+ query.bindValue(":hex", hash);\r
+ query.exec();\r
+ if (!query.next()) {\r
+ logger.log(logger.LOW, "Error finding note resource in RNoteTable.updateNoteResourceGuidbyHash. GUID="+noteGuid +" resGuid="+ resGuid+" hash="+hash);\r
+ return;\r
+ }\r
+ String guid = query.valueString(0);\r
+*/ \r
+ query.prepare("update noteresources set guid=:guid where noteGuid=:noteGuid and datahash=:hex");\r
+ query.bindValue(":guid", resGuid);\r
+ query.bindValue(":noteGuid", noteGuid);\r
+ query.bindValue(":hex", hash);\r
+ if (!query.exec()) {\r
+ logger.log(logger.EXTREME, "Note Resource Update by Hash failed");\r
+ logger.log(logger.EXTREME, query.lastError().toString());\r
+ }\r
+ }\r
+\r
+ // Fix CRLF problem that is on some notes\r
+ private String fixCarriageReturn(String note) {\r
+ if (note == null || !Global.enableCarriageReturnFix)\r
+ return note;\r
+ QByteArray a0Hex = new QByteArray("a0");\r
+ String a0 = QByteArray.fromHex(a0Hex).toString();\r
+ note = note.replace("<div>"+a0+"</div>", "<div> </div>");\r
+ return note.replace("<div/>", "<div> </div>");\r
+ }\r
+ \r
+ // Expunge notes that we don't want to synchronize\r
+ public List<String> expungeIgnoreSynchronizedNotes(List<String> notebooks, List<String>tags, List<String> linked) {\r
+ \r
+ List<String> noteGuids = new ArrayList<String>();\r
+ for (int i=0; i<notebooks.size(); i++) {\r
+ List<String> notes = findNotesByNotebook(notebooks.get(i));\r
+ for (int j=0; j<notes.size(); j++) {\r
+ if (!isNoteDirty(notes.get(j))) {\r
+ expungeNote(notes.get(j), true, false);\r
+ noteGuids.add(notes.get(j));\r
+ }\r
+ }\r
+ }\r
+ \r
+ for (int i=0; i<tags.size(); i++) {\r
+ List<String> notes = findNotesByTag(tags.get(i));\r
+ for (int j=0; j<notes.size(); j++) {\r
+ if (!isNoteDirty(notes.get(j))) {\r
+ expungeNote(notes.get(j), true, false);\r
+ noteGuids.add(notes.get(j));\r
+ }\r
+ }\r
+ }\r
+ \r
+ for (int i=0; i<linked.size(); i++) {\r
+ String notebookGuid = db.getLinkedNotebookTable().getNotebookGuid(linked.get(i));\r
+ if (notebookGuid != null && !notebookGuid.trim().equals("")) {\r
+ List<Tag> linkedTags = db.getTagTable().getTagsForNotebook(notebookGuid);\r
+ for (int j=0; j<linkedTags.size(); j++)\r
+ db.getTagTable().expungeTag(linkedTags.get(j).getGuid(), false);\r
+ \r
+ List<String> notes = findNotesByNotebook(notebookGuid);\r
+ for (int j=0; j<notes.size(); j++) {\r
+ if (!isNoteDirty(notes.get(j))) {\r
+ expungeNote(notes.get(j), true, false);\r
+ noteGuids.add(notes.get(j));\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return noteGuids;\r
+ }\r
+ \r
+ // Find a note by its notebook\r
+ // Expunge notes that we don't want to synchronize\r
+ public List<String> findNotesByNotebook(String notebook) {\r
+ List<String> values = new ArrayList<String>();\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Select guid from note where notebookguid=:notebook");\r
+\r
+ query.bindValue(":notebook", notebook);\r
+ query.exec();\r
+ while (query.next()) {\r
+ values.add(query.valueString(0));\r
+ }\r
+ return values;\r
}\r
\r
- // Get the title color of notes\r
- public List<Pair<String,Integer>> getNoteTitleColors() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Title_Colors;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responsePair;\r
+ public List<String> findNotesByTag(String tag) {\r
+ List<String> values = new ArrayList<String>();\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Select distinct noteguid from notetags where tagguid=:tag");\r
+\r
+ query.bindValue(":tag", tag);\r
+ query.exec();\r
+ while (query.next()) {\r
+ values.add(query.valueString(0));\r
+ }\r
+ return values;\r
}\r
\r
- // Get the title color of notes\r
- public void setNoteTitleColor(String guid, int color) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.string1 = new String(guid);\r
- request.int1 = color;\r
- request.type = NoteRequest.Set_Title_Colors;\r
- Global.dbRunner.addWork(request); \r
+ // Find a note based upon its title.\r
+ public List<Pair<String,String>> findNotesByTitle(String text) {\r
+ List<Pair<String,String>> results = new ArrayList<Pair<String,String>>();\r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("Select guid,title from Note where lower(title) like :title");\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL prepare for search by title has failed: " +query.lastError().toString());\r
+ \r
+ query.bindValue(":title", "%"+text.toLowerCase()+"%");\r
+ query.exec();\r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ Pair<String,String> p = new Pair<String,String>();\r
+ p.setFirst(query.valueString(0));\r
+ p.setSecond(query.valueString(1)); \r
+ results.add(p); \r
+ } \r
+ return results;\r
}\r
+\r
\r
\r
//********************************************************************************\r
//********************************************************************************\r
// set/unset a note to be reindexed\r
public void setIndexNeeded(String guid, Boolean flag) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Set_Index_Needed;\r
- request.string1 = new String(guid);\r
- request.bool1 = flag;\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("Update Note set indexNeeded=:flag where guid=:guid");\r
+\r
+ if (flag)\r
+ query.bindValue(":flag", 1);\r
+ else\r
+ query.bindValue(":flag", 0);\r
+ query.bindValue(":guid", guid);\r
+ if (!query.exec()) {\r
+ logger.log(logger.MEDIUM, "Note indexNeeded update failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ } \r
+ List<Resource> r = noteResourceTable.getNoteResources(guid, false);\r
+ for (int i=0; r!= null && i<r.size(); i++) {\r
+ noteResourceTable.setIndexNeeded(r.get(i).getGuid(), true);\r
+ }\r
}\r
// Set all notes to be reindexed\r
public void reindexAllNotes() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Reindex_All_Notes;\r
- Global.dbRunner.addWork(request);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ if (!query.exec("Update Note set indexNeeded=true")) {\r
+ logger.log(logger.MEDIUM, "Note reindexAllNotes update failed.");\r
+ logger.log(logger.MEDIUM, query.lastError());\r
+ } \r
}\r
+\r
// Get all unindexed notes\r
public List <String> getUnindexed() {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Unindexed;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseStrings;\r
+ String guid;\r
+ List<String> index = new ArrayList<String>();\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ if (!query.exec("Select guid from Note where isExpunged = false and indexNeeded = true and DATEDIFF('MINUTE',updated,CURRENT_TIMESTAMP)>5"))\r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed on getUnindexed().");\r
+\r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ guid = new String();\r
+ guid = query.valueString(0);\r
+ index.add(guid); \r
+ } \r
+ return index; \r
}\r
public List<String> getNextUnindexed(int limit) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Next_Unindexed;\r
- request.int1 = limit;\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseStrings;\r
+ List<String> guids = new ArrayList<String>();\r
+ \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ if (!query.exec("Select guid from Note where isExpunged = false and indexNeeded = true and DATEDIFF('MINUTE',Updated,CURRENT_TIMESTAMP)>5 limit " +limit))\r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed on getUnindexed().");\r
+ \r
+ // Get a list of the notes\r
+ String guid;\r
+ while (query.next()) {\r
+ guid = new String();\r
+ guid = query.valueString(0);\r
+ guids.add(guid);\r
+ } \r
+ return guids; \r
+ }\r
+\r
+ \r
+ // Get note meta information\r
+ public void updateNoteMetadata(NoteMetadata meta) {\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ if (!query.prepare("Update Note set titleColor=:color, pinned=:pinned, attributeSourceApplication=:metaString where guid=:guid"))\r
+ logger.log(logger.EXTREME, "Note SQL prepare has failed on updateNoteMetadata.");\r
+ query.bindValue(":color", meta.getColor());\r
+ query.bindValue(":pinned", meta.isPinned());\r
+ query.bindValue(":guid", meta.getGuid());\r
+ query.bindValue(":metaString", buildMetadataString(meta));\r
+ if (!query.exec()) \r
+ logger.log(logger.EXTREME, "Note SQL exec has failed on updateNoteMetadata.");\r
+ return;\r
+ }\r
+ \r
+ // Get all note meta information\r
+ public HashMap<String, NoteMetadata> getNotesMetaInformation() {\r
+ HashMap<String, NoteMetadata> returnValue = new HashMap<String, NoteMetadata>();\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ if (!query.exec("Select guid,titleColor, isDirty, pinned from Note"))\r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed on getNoteMetaInformation.");\r
+\r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ NoteMetadata note = new NoteMetadata();\r
+ note.setGuid(query.valueString(0));\r
+ note.setColor(query.valueInteger(1));\r
+ note.setDirty(query.valueBoolean(2, false));\r
+ int pinned = query.valueInteger(3);\r
+ if (pinned > 0) \r
+ note.setPinned(true);\r
+ returnValue.put(note.getGuid(), note); \r
+ } \r
+\r
+ return returnValue;\r
+ }\r
+ // Get note meta information\r
+ public NoteMetadata getNoteMetaInformation(String guid) {\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ if (!query.prepare("Select guid,titleColor, isDirty, pinned from Note where guid=:guid")) {\r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed on getNoteMetaInformation.");\r
+ return null;\r
+ }\r
+ query.bindValue(":guid", guid);\r
+ query.exec();\r
+\r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ NoteMetadata note = new NoteMetadata();\r
+ note.setGuid(query.valueString(0));\r
+ note.setColor(query.valueInteger(1));\r
+ note.setDirty(query.valueBoolean(2, false));\r
+ int pinned = query.valueInteger(3);\r
+ if (pinned > 0) \r
+ note.setPinned(true);\r
+ return note;\r
+ } \r
+\r
+ return null;\r
}\r
\r
\r
- //*********************************************************************************\r
- //* Thumbnail Functions\r
- //*********************************************************************************\r
+ //**********************************************************************************\r
+ //* Thumbnail functions\r
+ //**********************************************************************************\r
// Set if a new thumbnail is needed\r
public void setThumbnailNeeded(String guid, boolean needed) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Set_Thumbnail_Needed;\r
- request.string1 = new String(guid);\r
- request.bool1 = needed;\r
- Global.dbRunner.addWork(request);\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("Update note set thumbnailneeded = :needed where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ query.bindValue(":needed", needed);\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL set thumbail needed failed: " +query.lastError().toString());\r
+\r
}\r
// Is a thumbail needed for this guid?\r
public boolean isThumbnailNeeded(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Is_Thumbail_Needed;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseBoolean;\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("select thumbnailneeded from note where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL isThumbnailNeeded query failed: " +query.lastError().toString());\r
+ \r
+ boolean returnValue;\r
+ // Get a list of the notes\r
+ if (query.next()) \r
+ returnValue = query.valueBoolean(0, false); \r
+ else\r
+ returnValue = false;\r
+\r
+ return returnValue; \r
}\r
// Set if a new thumbnail is needed\r
public void setThumbnail(String guid, QByteArray thumbnail) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Set_Thumbnail;\r
- request.string1 = new String(guid);\r
- request.bytes = thumbnail;\r
- Global.dbRunner.addWork(request);\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("Update note set thumbnail = :thumbnail where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ query.bindValue(":thumbnail", thumbnail.toByteArray());\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL set thumbail failed: " +query.lastError().toString());\r
+\r
}\r
// Set if a new thumbnail is needed\r
public QByteArray getThumbnail(String guid) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Get_Thumbnail;\r
- request.string1 = new String(guid);\r
- Global.dbRunner.addWork(request);\r
- Global.dbClientWait(id);\r
- NoteRequest req = Global.dbRunner.noteResponse.get(id).copy();\r
- return req.responseBytes;\r
+ \r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("Select thumbnail from note where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL get thumbail failed: " +query.lastError().toString());\r
+ // Get a list of the notes\r
+ if (query.next()) {\r
+ try {\r
+ if (query.getBlob(0) != null) {\r
+ return new QByteArray(query.getBlob(0)); \r
+ }\r
+ } catch (java.lang.IllegalArgumentException e) {\r
+ return null;\r
+ }\r
+ }\r
+ return null;\r
+ }\r
+ // Get all thumbnails\r
+ public HashMap<String, QPixmap> getThumbnails() {\r
+ boolean check; \r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ HashMap<String, QPixmap> map = new HashMap<String,QPixmap>();\r
+ \r
+ check = query.prepare("Select guid,thumbnail from note where thumbnailneeded=false and isExpunged=false");\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL get thumbail failed: " +query.lastError().toString());\r
+ // Get a list of the notes\r
+ while (query.next()) {\r
+ try {\r
+ if (query.getBlob(1) != null) {\r
+ QByteArray data = new QByteArray(query.getBlob(1));\r
+ QPixmap img = new QPixmap();\r
+ if (img.loadFromData(data)) {\r
+ img = img.scaled(Global.largeThumbnailSize);\r
+ map.put(query.valueString(0), img);\r
+ }\r
+ } \r
+ } catch (java.lang.IllegalArgumentException e) {\r
+ logger.log(logger.HIGH, "Error retrieving thumbnail " +e.getMessage());\r
+ }\r
+ }\r
+ return map;\r
+ }\r
+ // Get a list of notes that need thumbnails\r
+ public List<String> findThumbnailsNeeded() {\r
+ \r
+ boolean check;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("select guid from note where thumbnailneeded=true and isExpunged=false and DATEDIFF('MINUTE',updated,CURRENT_TIMESTAMP)>5 limit 5");\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL findThumbnailsNeeded query failed: " +query.lastError().toString());\r
+ \r
+\r
+ // Get a list of the notes\r
+ List<String> values = new ArrayList<String>();\r
+ while (query.next()) {\r
+ values.add(query.valueString(0)); \r
+ }\r
+\r
+ return values; \r
+ }\r
+ // Get a count of thumbnails needed\r
+ public int getThumbnailNeededCount() {\r
+ \r
+ boolean check;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("select count(guid) from note where thumbnailneeded=true and isExpunged=false and DATEDIFF('MINUTE',updated,CURRENT_TIMESTAMP)>5 limit 2");\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL findThumbnailNeededCount query failed: " +query.lastError().toString());\r
+ \r
+ if (query.next()) {\r
+ return query.valueInteger(0); \r
+ }\r
+\r
+ return 0; \r
+ }\r
+\r
+ //***********************************************************************************\r
+ public String findAlternateGuid(String guid) {\r
+ boolean check;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("select guid from note where original_guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL findAlternateguid query failed: " +query.lastError().toString());\r
+ \r
+ if (query.next()) {\r
+ return query.valueString(0); \r
+ }\r
+\r
+ return null; \r
}\r
\r
+ //* Check if a note guid exists\r
+ public boolean guidExists(String guid) {\r
+ boolean check;\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ check = query.prepare("select guid from note where guid=:guid");\r
+ query.bindValue(":guid", guid);\r
+ check = query.exec();\r
+ if (!check) \r
+ logger.log(logger.EXTREME, "Note SQL guidExists query failed: " +query.lastError().toString());\r
+ \r
+ if (query.next()) {\r
+ return true; \r
+ }\r
\r
+ return false; \r
+ }\r
\r
// Update a note content's hash. This happens if a resource is edited outside of NN\r
public void updateResourceContentHash(String guid, String oldHash, String newHash) {\r
- NoteRequest request = new NoteRequest();\r
- request.requestor_id = id;\r
- request.type = NoteRequest.Update_Resource_Content_Hash;\r
- request.string1 = new String(guid);\r
- request.string2 = new String(oldHash);\r
- request.string3 = new String(newHash);\r
- Global.dbRunner.addWork(request);\r
+ Note n = getNote(guid, true, false, false, false,false);\r
+ int position = n.getContent().indexOf("<en-media");\r
+ int endPos;\r
+ for (;position>-1;) {\r
+ endPos = n.getContent().indexOf(">", position+1);\r
+ String oldSegment = n.getContent().substring(position,endPos);\r
+ int hashPos = oldSegment.indexOf("hash=\"");\r
+ int hashEnd = oldSegment.indexOf("\"", hashPos+7);\r
+ String hash = oldSegment.substring(hashPos+6, hashEnd);\r
+ if (hash.equalsIgnoreCase(oldHash)) {\r
+ String newSegment = oldSegment.replace(oldHash, newHash);\r
+ String content = n.getContent().substring(0,position) +\r
+ newSegment +\r
+ n.getContent().substring(endPos);\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ query.prepare("update note set isdirty=true, thumbnailneeded=true, content=:content where guid=:guid");\r
+ query.bindValue(":content", content);\r
+ query.bindValue(":guid", n.getGuid());\r
+ query.exec();\r
+ }\r
+ \r
+ position = n.getContent().indexOf("<en-media", position+1);\r
+ }\r
}\r
+\r
+ // Extract metadata from a note's Note.attributes.sourceApplication\r
+ private NoteMetadata extractMetadata(String sourceApplication) {\r
+ String consumerKey = "baumgarte:{";\r
+ int startPos = sourceApplication.indexOf(consumerKey);\r
+ if (startPos < 0 )\r
+ return null;\r
+ \r
+ NoteMetadata meta = new NoteMetadata();\r
+ startPos = startPos+consumerKey.length();\r
+ \r
+// String startString = sourceApplication.substring(0,startPos);\r
+ String metaString = sourceApplication.substring(startPos);\r
+// String endString = metaString.substring(metaString.indexOf("};"));\r
+ int endPos = metaString.indexOf("};");\r
+ if (endPos > 0)\r
+ metaString = metaString.substring(0,endPos);\r
+ \r
+ String value = parseMetaString(metaString, "titleColor");\r
+ if (value != null)\r
+ meta.setColor(Integer.parseInt(value));\r
+ \r
+ value = parseMetaString(metaString, "pinned");\r
+ if (value != null && value.equals(true))\r
+ meta.setPinned(true);\r
+ \r
+ return meta;\r
+ }\r
+ \r
+ // Given a metadata string from attribute.sourceApplication, we\r
+ // extract the information for a given key.\r
+ private String parseMetaString(String metaString, String key) {\r
+ int startPos = metaString.indexOf(key);\r
+ if (startPos < 0)\r
+ return null;\r
+ \r
+ String value = metaString.substring(startPos+key.length()+1);\r
+ int endPos = value.indexOf(";");\r
+ if (endPos > 0)\r
+ value = value.substring(0,endPos);\r
+ \r
+ return value;\r
+ }\r
+ \r
+ // Given a set of metadata, we build a string that can be inserted\r
+ // into the attribute.sourceApplication string.\r
+ private String buildMetadataString(NoteMetadata meta) {\r
+ StringBuffer value = new StringBuffer(removeExistingMetaString(meta.getGuid()));\r
+ StringBuffer metaString = new StringBuffer();\r
+ \r
+ if (meta.isPinned()) {\r
+ metaString.append("pinned=true;");\r
+ }\r
+ if (meta.getColor() != -1) {\r
+ metaString.append("titleColor=" +new Integer(meta.getColor()).toString()+";");\r
+ }\r
+ if (metaString.length()>0) {\r
+ \r
+ // Adda any missing ";" or " " at the end of the existing \r
+ // string.\r
+ if (value.length()>1 && (!value.toString().trim().endsWith(";") || !value.toString().trim().endsWith(";"))) \r
+ value.append("; ");\r
+ \r
+ value.append("baumgarte:{");\r
+ value.append(metaString);\r
+ value.append("};");\r
+ return value.toString();\r
+ }\r
+ return null;\r
+ }\r
+\r
+ // This will remove the existing metadata string from the attribute.sourceApplication string.\r
+ private String removeExistingMetaString(String guid) {\r
+ NSqlQuery query = new NSqlQuery(db.getConnection());\r
+ \r
+ if (!query.prepare("Select attributeSourceApplication from Note where guid=:guid")) {\r
+ logger.log(logger.EXTREME, "Note SQL retrieve has failed in removeExistingMetaString.");\r
+ return null;\r
+ }\r
+ query.bindValue(":guid", guid);\r
+ query.exec();\r
+\r
+ // Get the application source string\r
+ String sourceApplication = null;\r
+ while (query.next()) {\r
+ sourceApplication = query.valueString(0);\r
+ }\r
+ if (sourceApplication == null) \r
+ return "";\r
+ \r
+ String consumerKey = "baumgarte:{";\r
+ int startPos = sourceApplication.indexOf(consumerKey);\r
+ if (startPos < 0 )\r
+ return sourceApplication;\r
+ String startString = sourceApplication.substring(0,startPos);\r
+ String metaString = sourceApplication.substring(startPos);\r
+ String endString = metaString.substring(metaString.indexOf("};")+2);\r
+\r
+ return startString+endString;\r
+ }\r
+\r
} \r
+\r
+\r
+\r
+\r
OSDN Git Service
