mirror of
https://github.com/leanote/desktop-app.git
synced 2025-10-19 10:07:12 +00:00
520 lines
14 KiB
JavaScript
520 lines
14 KiB
JavaScript
var async = require('async');
|
|
var db = require('db');
|
|
var User = require('user');
|
|
var Notebook = require('notebook');
|
|
var Tag = require('tag');
|
|
// var Api = require('api');
|
|
var Server = require('server');
|
|
var Common = require('common');
|
|
var Notes = db.notes;
|
|
|
|
var Api = null; // require('api')
|
|
|
|
function log(o) {
|
|
console.log(o);
|
|
}
|
|
|
|
// 笔记服务
|
|
var Note = {
|
|
/*
|
|
type NoteOrContent struct {
|
|
NotebookId string
|
|
NoteId string
|
|
UserId string
|
|
Title string
|
|
Desc string
|
|
ImgSrc string
|
|
Tags []string
|
|
Content string
|
|
Abstract string
|
|
IsNew bool
|
|
IsMarkdown bool
|
|
FromUserId string // 为共享而新建
|
|
IsBlog bool // 是否是blog, 更新note不需要修改, 添加note时才有可能用到, 此时需要判断notebook是否设为Blog
|
|
}
|
|
*/
|
|
// 更新笔记
|
|
updateNoteOrContent: function(noteOrContent, callback) {
|
|
var userId = User.getCurActiveUserId();
|
|
noteOrContent['UserId'] = userId;
|
|
log('update');
|
|
var date = new Date();
|
|
noteOrContent.UpdatedTime = date;
|
|
|
|
noteOrContent['IsDirty'] = true; // 已修改
|
|
|
|
// 新建笔记, IsNew还是保存着
|
|
if(noteOrContent.IsNew) {
|
|
noteOrContent.CreatedTime = date;
|
|
noteOrContent['IsTrash'] = false;
|
|
delete noteOrContent['IsNew'];
|
|
noteOrContent['LocalIsNew'] = true;
|
|
Notes.insert(noteOrContent, function (err, newDoc) { // Callback is optional
|
|
if(err) {
|
|
console.log(err);
|
|
callback && callback(false);
|
|
} else {
|
|
// 为什么又设置成true, 因为js的对象是共享的, callback用到了noteOrContent.IsNew来做判断
|
|
noteOrContent['IsNew'] = true;
|
|
callback && callback(newDoc);
|
|
|
|
// 重新统计笔记本的笔记数量
|
|
Notebook.reCountNotebookNumberNotes(noteOrContent.NotebookId);
|
|
// 标签
|
|
if(noteOrContent.Tags && noteOrContent.Tags.length > 0) {
|
|
Tag.addTags(noteOrContent.Tags);
|
|
}
|
|
}
|
|
});
|
|
// 更新笔记
|
|
} else {
|
|
var updateFields = ['Desc', 'ImgSrc', 'Title', 'Tags', 'Content'];
|
|
var updates = {};
|
|
var needUpdate = false;
|
|
for(var i in updateFields) {
|
|
var field = updateFields[i];
|
|
if(field in noteOrContent) {
|
|
updates[field] = noteOrContent[field];
|
|
needUpdate = true;
|
|
}
|
|
}
|
|
if('Content' in updateFields) {
|
|
// 内容更新了, 因为内容是以后才从远程获取的, 获取内容后改变ContentIsDirty=false
|
|
noteOrContent['ContentIsDirty'] = true;
|
|
}
|
|
if(needUpdate) {
|
|
updates['IsDirty'] = true;
|
|
updates.UpdatedTime = date;
|
|
// Set an existing field's value
|
|
Notes.update({NoteId: noteOrContent.NoteId}, { $set: updates }, {}, function (err, numReplaced) {
|
|
if(err) {
|
|
log(err);
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(noteOrContent);
|
|
// 标签
|
|
if(noteOrContent.Tags && noteOrContent.Tags.length > 0) {
|
|
Tag.addTags(noteOrContent.Tags);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
},
|
|
|
|
|
|
|
|
// 获取笔记列表
|
|
getNotes: function(notebookId, callback) {
|
|
var me = this;
|
|
me._getNotes(notebookId, false, callback);
|
|
},
|
|
// 获取trash笔记
|
|
getTrashNotes: function(callback) {
|
|
var me = this;
|
|
me._getNotes('', true, callback);
|
|
},
|
|
_getNotes: function(notebookId, isTrash, callback) {
|
|
var userId = User.getCurActiveUserId();
|
|
var query = {
|
|
UserId: userId,
|
|
IsTrash: false,
|
|
};
|
|
if(notebookId) {
|
|
query['NotebookId'] = notebookId;
|
|
}
|
|
if(isTrash) {
|
|
query['IsTrash'] = true;
|
|
}
|
|
Notes.find(query).sort({'UpdatedTime': -1}).exec(function(err, notes) {
|
|
if(err) {
|
|
log(err);
|
|
return callback && callback(false);
|
|
}
|
|
return callback && callback(notes);
|
|
});
|
|
},
|
|
|
|
// 得到笔记
|
|
getNote: function(noteId, callback) {
|
|
var me = this;
|
|
Notes.findOne({NoteId: noteId}, function(err, doc) {
|
|
if(err || !doc) {
|
|
log('不存在');
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(doc);
|
|
}
|
|
});
|
|
},
|
|
|
|
// 远程修改本地内容
|
|
updateNoteContentForce: function(noteId, content, callback) {
|
|
// <img src="http://localhost:9000/api/file/getImage?fileId=54c2083f99c37bea5f000001">
|
|
// 改成<img src="http://localhost:3232/api/file/getImage?fileId=xxx"
|
|
if(!Api) {
|
|
Api = require('api');
|
|
}
|
|
|
|
var reg = new RegExp('src="' + Api.leanoteUrl + '/api/file/getImage', 'g');
|
|
content = content.replace(reg, 'src="' + Server.localUrl + '/api/file/getImage');
|
|
|
|
log("----<>");
|
|
log(content);
|
|
Notes.update({NoteId: noteId}, { $set: {Content: content, InitSync: false, IsContentDirty: false} }, {}, function (err, numReplaced) {
|
|
if(err) {
|
|
log(err);
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(content);
|
|
}
|
|
});
|
|
},
|
|
|
|
/*
|
|
// 同步内容
|
|
updateNoteContentForce: function(noteId, content, callback) {
|
|
// 将笔记内容中
|
|
|
|
Notes.update({NoteId: noteId}, { $set: {Content: content, InitSync: false} }, {}, function (err, numReplaced) {
|
|
if(err) {
|
|
log(err);
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(content);
|
|
}
|
|
});
|
|
},
|
|
*/
|
|
|
|
// 得到笔记内容
|
|
// noteId是本地Id
|
|
getNoteContent: function(noteId, callback) {
|
|
var me = this;
|
|
log('getNoteContent------')
|
|
me.getNote(noteId, function(note) {
|
|
if(!Common.isOk(note)) {
|
|
log('not ok');
|
|
log(note);
|
|
callback && callback(false);
|
|
} else {
|
|
// 如果笔记是刚同步过来的, 那么内容要重新获取
|
|
if(note.InitSync) {
|
|
log('need load from server');
|
|
|
|
if(!Api) {
|
|
Api = require('api')
|
|
}
|
|
|
|
// 远程获取
|
|
me.getServerNoteIdByNoteId(noteId, function(serverNoteId) {
|
|
if(!serverNoteId) {
|
|
return callback && callback(false);
|
|
}
|
|
|
|
Api.getNoteContent(serverNoteId, function(noteContent) {
|
|
// 同步到本地
|
|
if(Common.isOk(noteContent)) {
|
|
me.updateNoteContentForce(noteId, noteContent.Content, function(content) {
|
|
noteContent.Content = content;
|
|
noteContent.NoteId = noteId;
|
|
callback && callback(noteContent);
|
|
});
|
|
} else {
|
|
callback && callback(false);
|
|
}
|
|
});
|
|
|
|
});
|
|
} else {
|
|
log('not need');
|
|
callback && callback(note);
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
//----------------
|
|
// 同步
|
|
//----------------
|
|
|
|
getNoteByServerNoteId: function(noteId, callback) {
|
|
var me = this;
|
|
Notes.findOne({ServerNoteId: noteId}, function(err, doc) {
|
|
if(err || !doc) {
|
|
log('getNoteByServerNoteId 不存在' + noteId);
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(doc);
|
|
}
|
|
});
|
|
},
|
|
getNoteIdByServerNoteId: function(noteId, callback) {
|
|
var me = this;
|
|
Notes.findOne({ServerNoteId: noteId}, function(err, doc) {
|
|
if(err || !doc) {
|
|
log('getNoteIdByServerNoteId 不存在' + noteId);
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(doc.NoteId);
|
|
}
|
|
});
|
|
},
|
|
getServerNoteIdByNoteId: function(noteId, callback) {
|
|
var me = this;
|
|
Notes.findOne({NoteId: noteId}, function(err, doc) {
|
|
if(err || !doc) {
|
|
log('getServerNoteIdByNoteId 不存在');
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(doc.ServerNoteId);
|
|
}
|
|
});
|
|
},
|
|
|
|
// 强制删除
|
|
// TODO 是否真的删除 ?
|
|
// 有可能服务器上删除了是误删 ?
|
|
deleteNoteForce: function(noteId, callback) {
|
|
var me = this;
|
|
Notes.remove({ServerNoteId: noteId}, function(err, n) {
|
|
if(err) {
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(true);
|
|
}
|
|
});
|
|
},
|
|
// 添加笔记本, note object
|
|
// note是服务器传过来的, 需要处理下fix
|
|
// NoteId, ServerNoteId, NotebookId(本地的)
|
|
addNoteForce: function(note, callback) {
|
|
note.InitSync = true; // 刚同步完, 表示content, images, attach没有同步
|
|
note.IsDirty = false;
|
|
note.ServerNoteId = note.NoteId;
|
|
note.NoteId = Common.objectId();
|
|
Notebook.getNotebookIdByServerNotebookId(note.NotebookId, function(localNotebookId) {
|
|
note.NotebookId = localNotebookId;
|
|
Notes.insert(note, function (err, newDoc) { // Callback is optional
|
|
if(err) {
|
|
console.log(err);
|
|
callback && callback(false);
|
|
} else {
|
|
callback && callback(newDoc);
|
|
}
|
|
});
|
|
});
|
|
},
|
|
// 更新笔记本, 合并之, 内容要重新获取
|
|
// note是服务器传过来的, 需要处理下fix
|
|
updateNoteForce: function(note, callback) {
|
|
var me = this;
|
|
note.IsDirty = false;
|
|
note.InitSync = true;
|
|
note.LocalIsNew = false;
|
|
me.getNoteIdByServerNoteId(note.NoteId, function(localNoteId) {
|
|
note.NoteId = localNoteId;
|
|
Notebook.getNotebookIdByServerNotebookId(note.NotebookId, function(localNotebookId) {
|
|
note['NotebookId'] = localNotebookId;
|
|
Notes.update({NoteId: localNoteId}, {$set: note}, {}, function (err, cnt) { // Callback is optional
|
|
if(err) {
|
|
console.log(err);
|
|
callback && callback(false);
|
|
} else {
|
|
log('强制更新...');
|
|
callback && callback(note);
|
|
}
|
|
});
|
|
});
|
|
|
|
});
|
|
},
|
|
|
|
// 添加修改ServerNoteId; 更新修改usn
|
|
updateNoteForceForSendChange: function(note, callback) {
|
|
var me = this;
|
|
note.IsDirty = false;
|
|
note.InitSync = false;
|
|
note.LocalIsNew = false;
|
|
Notes.update({NoteId: note.NoteId}, {$set: note}, function(err, n) {
|
|
if(err || !n) {
|
|
log('updateNoteForceForSendChange err');
|
|
log(err);
|
|
return callback && callback(false);
|
|
}
|
|
return callback && callback(true);
|
|
});
|
|
},
|
|
|
|
// 服务器上的数据
|
|
// 为冲突更新, note已有有NoteId, ServerNoteId, 但NotebookId是服务器端的
|
|
updateNoteForceForConflict: function(note, callback) {
|
|
var me = this;
|
|
note.IsDirty = false;
|
|
note.InitSync = true;
|
|
note.LocalIsNew = false;
|
|
Notebook.getNotebookIdByServerNotebookId(note.NotebookId, function(localNotebookId) {
|
|
note['NotebookId'] = localNotebookId;
|
|
Notes.update({NoteId: note.NoteId}, {$set: note}, {}, function (err, cnt) { // Callback is optional
|
|
if(err) {
|
|
console.log(err);
|
|
callback && callback(false);
|
|
} else {
|
|
log('强制更新...');
|
|
callback && callback(note);
|
|
}
|
|
});
|
|
});
|
|
},
|
|
|
|
// 将本地冲突的笔记复制一份
|
|
// serverNoteId
|
|
copyNoteForConfict: function(noteId, callback) {
|
|
var me = this;
|
|
me.getNote(noteId, function(note) {
|
|
if(!note) {
|
|
return;
|
|
}
|
|
// 新Id
|
|
delete note['_id'];
|
|
note.NoteId = Common.objectId();
|
|
note.ConflictNoteId = noteId; // 与noteId有冲突
|
|
note.ConflictTime = new Date(); // 发生冲突时间
|
|
note.ConflictFixed = false; // 冲突未解决
|
|
note.IsDirty = true;
|
|
note.LocalIsNew = true;
|
|
note.InitSync = false; // 都是本地的, 相当于新建的笔记
|
|
|
|
Notes.insert(note, function(err, newNote) {
|
|
if(err) {
|
|
callback(false);
|
|
} else {
|
|
callback(newNote);
|
|
}
|
|
});
|
|
|
|
});
|
|
},
|
|
|
|
// 处理冲突
|
|
// notes是服务器的数据, 与本地的有冲突
|
|
// 1) 将本地的note复制一份
|
|
// 2) 服务器替换之前
|
|
fixConflicts: function(noteSyncInfo, noteWeb, callback) {
|
|
var me = this;
|
|
// 处理冲突
|
|
if(!noteWeb) {
|
|
return callback && callback();
|
|
}
|
|
|
|
var conflictNotes = noteSyncInfo.conflicts;
|
|
log('fix note conflicts');
|
|
log(conflictNotes);
|
|
// 这里为什么要同步? 因为fixConflicts后要进行send changes, 这些有冲突的不能发送changes
|
|
if(conflictNotes) {
|
|
async.eachSeries(conflictNotes, function(note, cb) { // note是服务器上最新的
|
|
var noteId = note.NoteId; // 本地noteId
|
|
// 复制一份
|
|
me.copyNoteForConfict(noteId, function(newNote) {
|
|
if(newNote) {
|
|
// 更新之前的
|
|
me.updateNoteForceForConflict(note, function(note2) {
|
|
if(note2) {
|
|
// 前端来处理, 全量sync时不用前端一个个处理
|
|
noteWeb && noteWeb.fixSyncConflict(note2, newNote);
|
|
}
|
|
cb();
|
|
});
|
|
} else {
|
|
cb();
|
|
}
|
|
});
|
|
}, function() {
|
|
// 最后调用
|
|
callback && callback();
|
|
});
|
|
} else {
|
|
callback && callback();
|
|
}
|
|
|
|
// 发送改变的冲突
|
|
// 复制一份
|
|
// [待测]
|
|
var changeConflicts = noteSyncInfo.changeConflicts;
|
|
for(var i in changeConflicts) {
|
|
var note = changeConflicts[i]; // note是本地的note
|
|
// 复制一份
|
|
me.copyNoteForConfict(note.NoteId, function(newNote) {
|
|
if(newNote) {
|
|
// 更新之前的, 要先从服务器上得到服务版的
|
|
// 这里的note是本地的, 所以将服务器上的覆盖它
|
|
if(!Api) {
|
|
Api = require('api');
|
|
}
|
|
Api.getNote(note.ServerNoteId, function(serverNote) {
|
|
serverNote.ServerNoteId = serverNote.NoteId;
|
|
serverNote.NoteId = note.NoteId;
|
|
me.updateNoteForceForConflict(serverNote, function(err, note2) {
|
|
if(!err) {
|
|
// 前端来处理, 全量sync时不用前端一个个处理
|
|
noteWeb && noteWeb.fixSyncConflict(note2, newNote);
|
|
}
|
|
});
|
|
});
|
|
} else {
|
|
}
|
|
});
|
|
}
|
|
|
|
// 服务器没有, 但是是发送更新的, 所以需要作为添加以后再send changes
|
|
if(noteSyncInfo.changeNeedAdds) {
|
|
var needAddNotes = noteSyncInfo.changeNeedAdds;
|
|
for(var i in needAddNotes) {
|
|
log('need add ');
|
|
var note = needAddNotes[i];
|
|
me.setIsNew(note.NoteId);
|
|
}
|
|
}
|
|
|
|
// 处理添加的
|
|
var addNotes = noteSyncInfo.adds;
|
|
log('has add...');
|
|
log(addNotes);
|
|
noteWeb.addSync(addNotes);
|
|
|
|
log('has updates...');
|
|
log(noteSyncInfo);
|
|
log(noteSyncInfo.updates);
|
|
// 处理更新的
|
|
noteWeb.updateSync(noteSyncInfo.updates);
|
|
|
|
// 处理删除的
|
|
noteWeb.deleteSync(noteSyncInfo.deletes);
|
|
},
|
|
|
|
// 获得用户修改的笔记
|
|
getDirtyNotes: function(callback) {
|
|
Notes.find({UserId: User.getCurActiveUserId(), IsDirty: true}, function(err, notes) {
|
|
if(err) {
|
|
log(err);
|
|
return callback && callback(false);
|
|
} else {
|
|
callback(notes);
|
|
}
|
|
});
|
|
},
|
|
|
|
// 在send delete笔记时成功
|
|
setNotDirty: function(noteId) {
|
|
Notes.update({NoteId: noteId}, {$set:{IsDirty: false}})
|
|
},
|
|
// 在send delete笔记时有冲突, 设为不删除
|
|
setNotDirtyNotDelete: function(noteId) {
|
|
Notes.update({NoteId: noteId}, {$set:{IsDirty: false, LocalIsDelete: false}})
|
|
},
|
|
setIsNew: function(noteId) {
|
|
Notes.update({NoteId: noteId}, {$set:{LocalIsNew: true, IsDirty: true}})
|
|
}
|
|
};
|
|
|
|
module.exports = Note; |