void NotebookProperties::okButtonPressed() {
okPressed = true;
if (this->lid > 0) {
Notebook book;
NotebookTable table;
table.get(book, lid);
book.name = name.text().trimmed().toStdString();
book.__isset.name = true;
table.update(book, true);
close();
return;
}
// We have a new notebook to add
Notebook book;
book.name = name.text().trimmed().toStdString();
bool isSynchronized = syncBox.isChecked();
QUuid uuid;
QString g = uuid.createUuid().toString().replace("{","").replace("}","");
book.guid = g.toStdString();
book.__isset.name = true;
book.__isset.guid = true;
NotebookTable t;
t.add(0,book,true, !isSynchronized);
close();
}
// Add a new note to the database
qint32 NoteTable::add(qint32 l, Note &t, bool isDirty) {
QLOG_DEBUG() << "Adding note: " << QString::fromStdString(t.title);
ResourceTable resTable;
ConfigStore cs;
QSqlQuery query;
qint32 position;
TagScanner scanner;
qint32 lid = l;
qint32 notebookLid;
query.prepare("Insert into DataStore (lid, key, data) values (:lid, :key, :data)");
if (lid <= 0)
lid = cs.incrementLidCounter();
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_GUID);
query.bindValue(":data", QString::fromStdString(t.guid));
query.exec();
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_INDEX_NEEDED);
query.bindValue(":data", true);
query.exec();
if (t.__isset.title) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_TITLE);
query.bindValue(":data", QString::fromStdString(t.title.c_str()));
query.exec();
}
if (t.__isset.content) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_CONTENT);
QByteArray b;
b.append(QString::fromStdString(t.content).toAscii());
query.bindValue(":data", b);
query.exec();
}
if (t.__isset.contentHash) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_CONTENT_HASH);
query.bindValue(":data", QString::fromStdString(t.contentHash));
query.exec();
}
if (t.__isset.contentLength) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_CONTENT_LENGTH);
query.bindValue(":data", t.contentLength);
query.exec();
}
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_UPDATE_SEQUENCE_NUMBER);
query.bindValue(":data", t.updateSequenceNum);
query.exec();
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ISDIRTY);
query.bindValue(":data", isDirty);
query.exec();
if (t.__isset.created) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_CREATED_DATE);
query.bindValue(":data", QVariant::fromValue(t.created));
query.exec();
}
if (t.__isset.updated) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_UPDATED_DATE);
query.bindValue(":data", QVariant::fromValue(t.updated));
query.exec();
}
if (t.__isset.deleted) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_DELETED_DATE);
query.bindValue(":data", QVariant::fromValue(t.deleted));
query.exec();
}
if (t.__isset.active) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ACTIVE);
query.bindValue(":data", QVariant::fromValue(t.active));
query.exec();
}
if (t.__isset.notebookGuid) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_NOTEBOOK_LID);
NotebookTable notebookTable;
notebookLid = notebookTable.getLid(QString::fromStdString(t.notebookGuid));
// If not found, we insert one to avoid problems. We'll probably get the real data later
if (notebookLid == 0) {
notebookLid = cs.incrementLidCounter();
Notebook notebook;
notebook.guid = t.notebookGuid;
notebook.name = "";
notebook.__isset.guid = true;
notebook.__isset.name = true;
notebookTable.add(notebookLid, notebook, false, false);
}
query.bindValue(":data", notebookLid);
query.exec();
}
for (unsigned int i=0; t.__isset.tagGuids && i<t.tagGuids.size(); i++) {
TagTable tagTable;
qint32 tagLid = tagTable.getLid(t.tagGuids.at(i));
if (tagLid == 0) {
// create a dummy tag to avoid later problems
Tag newTag;
newTag.guid = t.tagGuids.at(i);
newTag.name = "";
newTag.__isset.guid = true;
newTag.__isset.name = true;
tagLid = cs.incrementLidCounter();
tagTable.add(tagLid, newTag, false, 0);
}
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_TAG_LID);
query.bindValue(":data", tagLid);
query.exec();
}
for (unsigned int i=0; t.__isset.resources && i<t.resources.size(); i++) {
qint32 resLid;
Resource *r;
r = &t.resources[i];
resLid = resTable.getLid(t.guid,t.resources[i].guid);
if (resLid == 0)
resLid = cs.incrementLidCounter();
resTable.add(resLid, t.resources[i], isDirty);
if (r->__isset.mime) {
QString mime = QString::fromStdString(r->mime);
if (!mime.startsWith("image/") && mime != "vnd.evernote.ink") {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_HAS_ATTACHMENT);
query.bindValue(":data", true);
query.exec();
}
}
}
if (t.__isset.attributes) {
if (t.attributes.__isset.subjectDate) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_SUBJECT_DATE);
query.bindValue(":data", QVariant::fromValue(t.attributes.subjectDate));
query.exec();
}
if (t.attributes.__isset.latitude) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_LATITUDE);
query.bindValue(":data", QVariant::fromValue(t.attributes.latitude));
query.exec();
}
if (t.attributes.__isset.latitude) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_LONGITUDE);
query.bindValue(":data", QVariant::fromValue(t.attributes.longitude));
query.exec();
}
if (t.attributes.__isset.altitude) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_ALTITUDE);
query.bindValue(":data", QVariant::fromValue(t.attributes.altitude));
query.exec();
}
if (t.attributes.__isset.author) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_AUTHOR);
query.bindValue(":data", QString::fromStdString(t.attributes.author));
query.exec();
}
if (t.attributes.__isset.source) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_SOURCE);
query.bindValue(":data", QString::fromStdString(t.attributes.source));
query.exec();
}
if (t.attributes.__isset.sourceURL) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_SOURCE_URL);
query.bindValue(":data", QString::fromStdString(t.attributes.sourceURL));
query.exec();
}
if (t.attributes.__isset.sourceApplication) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_SOURCE_APPLICATION);
query.bindValue(":data", QString::fromStdString(t.attributes.sourceApplication));
query.exec();
}
if (t.attributes.__isset.shareDate) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_SHARE_DATE);
query.bindValue(":data",QVariant::fromValue(t.attributes.shareDate));
query.exec();
}
if (t.attributes.__isset.placeName) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_PLACE_NAME);
query.bindValue(":data", QString::fromStdString(t.attributes.placeName));
query.exec();
}
if (t.attributes.__isset.contentClass) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_ATTRIBUTE_CONTENT_CLASS);
query.bindValue(":data", QString::fromStdString(t.attributes.contentClass));
query.exec();
}
}
// No determine some attributes of the note based upon the content
// This should probably happen every time a note changes? Or at least something simular:
QString content;
if (t.__isset.content)
content = QString::fromStdString(t.content);
else
content = "";
position = content.indexOf("<en-crypt");
if (position > 0) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_HAS_ENCRYPT);
query.bindValue(":data", true);
query.exec();
}
position = content.indexOf("<en-todo");
if (position > 0) {
position = content.indexOf("<en-todo checked=\"true\"");
if (position > 0) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_HAS_TODO_COMPLETED);
query.bindValue(":data", true);
query.exec();
}
position = qMax(content.indexOf("<en-todo checked=\"false\""), content.indexOf("<en-todo>"));
if (position > 0) {
query.bindValue(":lid", lid);
query.bindValue(":key", NOTE_HAS_TODO_UNCOMPLETED);
query.bindValue(":data", true);
query.exec();
}
}
updateNoteList(lid, t, isDirty);
return lid;
}
//***********************************************************
//* Process a <notebook> node
//***********************************************************
void ImportData::processNotebookNode() {
Notebook notebook;
bool notebookIsDirty = false;
bool notebookIsLocal = false;
bool notebookIsReadOnly = false;
// notebookIcon = null;
bool atEnd = false;
// Loop through until we hit </notebook>
while(!atEnd) {
if (backup || importNotebooks) {
if (reader->isStartElement()) {
QString name = reader->name().toString().toLower();
if (name == "guid") {
notebook.guid = textValue().toStdString();
notebook.__isset.guid = true;
}
if (name == "name") {
notebook.name = textValue().toStdString();
notebook.__isset.name = true;
}
if (name == "updatesequencenumber") {
notebook.updateSequenceNum = intValue();
notebook.__isset.updateSequenceNum = true;
}
if (name == "servicecreated") {
notebook.serviceCreated = longValue();
notebook.__isset.serviceCreated = true;
}
if (name == "serviceupdated") {
notebook.serviceUpdated = longValue();
notebook.__isset.serviceUpdated = true;
}
if (name == "defaultnotebook") {
notebook.defaultNotebook = booleanValue();
notebook.__isset.defaultNotebook = true;
}
if (name == "dirty") {
if (booleanValue())
notebookIsDirty = true;
}
if (name == "localnotebook") {
if (booleanValue())
notebookIsLocal = true;
}
if (name == "readonly") {
if (booleanValue())
notebookIsReadOnly = true;
}
if (name == "publishingpublicdescription") {
notebook.publishing.publicDescription = textValue().toStdString();
notebook.publishing.__isset.publicDescription = true;
}
if (name == "publishinguri") {
notebook.publishing.uri = textValue().toStdString();
notebook.publishing.__isset.uri = true;
}
if (name == "publishingorder") {
//notebook->publishing.order =
// NoteSortOrder.;
QLOG_DEBUG() << "!!!!!!!!!!!! PublishingOrder not completed in import";
}
if (name == "PublishingAscending") {
if (booleanValue())
notebook.publishing.ascending = true;
else
notebook.publishing.ascending = false;
notebook.publishing.__isset.ascending = true;
}
if (name == "icon") {
//byte[] b = textValue().getBytes(); // data binary
//QByteArray hexData = new QByteArray(b);
//QByteArray binData = new QByteArray(QByteArray.fromHex(hexData));
//notebookIcon = new QIcon(QPixmap.fromImage(QImage.fromData(binData)));
}
if (name == "stack") {
notebook.stack = textValue().toStdString();
notebook.__isset.stack = true;
}
}
}
reader->readNext();
QString endName = reader->name().toString().toLower();
if (endName == "notebook" && reader->isEndElement())
atEnd = true;
}
// We are at the end. We should have a valid notebook now
NotebookTable notebookTable;
// Check if there is a notebook by this name already.
// If one exists, we treat this as an update
qint32 lid = notebookTable.findByName(notebook.name);
if (lid == 0)
lid = notebookTable.getLid(notebook.guid);
if (lid == 0) {
notebookTable.add(lid,notebook,notebookIsDirty, notebookIsLocal);
} else {
notebookTable.sync(lid, notebook);
notebookTable.setDirty(lid, notebookIsDirty);
}
return;
}
