hyperzlib
/
nodebb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: #7743 posts/diff, posts/edit

Browse Source
v1.18.x
Baris Usakli 6 years ago
parent acad245b4a
commit c4bb467ea5
2 changed files with 181 additions and 263 deletions
Show Stats Download Patch File Download Diff File

184
src/posts/diffs.js
Unescape Escape View File

@ -1,121 +1,89 @@
'use strict'; 'use strict';
var async = require('async'); const validator = require('validator');
var validator = require('validator'); const diff = require('diff');
var diff = require('diff');
var db = require('../database'); const db = require('../database');
var meta = require('../meta'); const meta = require('../meta');
var plugins = require('../plugins'); const plugins = require('../plugins');
var translator = require('../translator'); const translator = require('../translator');
var Diffs = {};
Diffs.exists = function (pid, callback) { module.exports = function (Posts) {
if (meta.config.enablePostHistory !== 1) { const Diffs = {};
return callback(null, 0); Posts.diffs = Diffs;
} Diffs.exists = async function (pid) {
if (meta.config.enablePostHistory !== 1) {
db.listLength('post:' + pid + ':diffs', function (err, numDiffs) { return false;
return callback(err, !!numDiffs); }
});
};
Diffs.get = function (pid, since, callback) {
async.waterfall([
function (next) {
Diffs.list(pid, next);
},
function (timestamps, next) {
// Pass those made after `since`, and create keys
const keys = timestamps.filter(function (timestamp) {
return (parseInt(timestamp, 10) || 0) >= since;
}).map(function (timestamp) {
return 'diff:' + pid + '.' + timestamp;
});
db.getObjects(keys, next);
},
], callback);
};
Diffs.list = function (pid, callback) {
db.getListRange('post:' + pid + ':diffs', 0, -1, callback);
};
Diffs.save = function (pid, oldContent, newContent, callback) {
const now = Date.now();
const patch = diff.createPatch('', newContent, oldContent);
async.parallel([
async.apply(db.listPrepend.bind(db), 'post:' + pid + ':diffs', now),
async.apply(db.setObject.bind(db), 'diff:' + pid + '.' + now, {
pid: pid,
patch: patch,
}),
], function (err) {
// No return arguments passed back
callback(err);
});
};
Diffs.load = function (pid, since, uid, callback) {
var Posts = require('../posts');
// Retrieves all diffs made since `since` and replays them to reconstruct what the post looked like at `since`
since = parseInt(since, 10);
if (isNaN(since) || since > Date.now()) {
return callback(new Error('[[error:invalid-data]]'));
}
async.parallel({ const numDiffs = await db.listLength('post:' + pid + ':diffs');
post: async.apply(Posts.getPostSummaryByPids, [pid], uid, { return !!numDiffs;
parse: false, };
}),
diffs: async.apply(Posts.diffs.get, pid, since), Diffs.get = async function (pid, since) {
}, function (err, data) { const timestamps = await Diffs.list(pid);
if (err) { // Pass those made after `since`, and create keys
return callback(err); const keys = timestamps.filter(t => (parseInt(t, 10) || 0) >= since)
.map(t => 'diff:' + pid + '.' + t);
return await db.getObjects(keys);
};
Diffs.list = async function (pid) {
return await db.getListRange('post:' + pid + ':diffs', 0, -1);
};
Diffs.save = async function (pid, oldContent, newContent) {
const now = Date.now();
const patch = diff.createPatch('', newContent, oldContent);
await Promise.all([
db.listPrepend('post:' + pid + ':diffs', now),
db.setObject('diff:' + pid + '.' + now, {
pid: pid,
patch: patch,
}),
]);
};
Diffs.load = async function (pid, since, uid) {
// Retrieves all diffs made since `since` and replays them to reconstruct what the post looked like at `since`
since = parseInt(since, 10);
if (isNaN(since) || since > Date.now()) {
throw new Error('[[error:invalid-data]]');
} }
const [post, diffs] = await Promise.all([
Posts.getPostSummaryByPids([pid], uid, { parse: false }),
Posts.diffs.get(pid, since),
]);
const data = {
post: post,
diffs: diffs,
};
postDiffLoad(data); postDiffLoad(data);
const result = await plugins.fireHook('filter:parse.post', { postData: data.post });
result.postData.content = translator.escape(result.postData.content);
return result.postData;
};
function postDiffLoad(data) {
data.post = data.post[0];
data.post.content = validator.unescape(data.post.content);
// Replace content with re-constructed content from that point in time
data.post.content = data.diffs.reduce(function (content, currentDiff) {
const result = diff.applyPatch(content, currentDiff.patch, {
fuzzFactor: 1,
});
async.waterfall([ return typeof result === 'string' ? result : content;
function (next) { }, data.post.content);
plugins.fireHook('filter:parse.post', { postData: data.post }, next);
},
function (data, next) {
data.postData.content = translator.escape(data.postData.content);
next(null, data.postData);
},
], callback);
});
};
function postDiffLoad(data) {
data.post = data.post[0];
data.post.content = validator.unescape(data.post.content);
// Replace content with re-constructed content from that point in time
data.post.content = data.diffs.reduce(function (content, currentDiff) {
const result = diff.applyPatch(content, currentDiff.patch, {
fuzzFactor: 1,
});
return typeof result === 'string' ? result : content;
}, data.post.content);
// Clear editor data (as it is outdated for this content)
delete data.post.edited;
data.post.editor = null;
data.post.content = String(data.post.content || '');
}
module.exports = function (Posts) { // Clear editor data (as it is outdated for this content)
Posts.diffs = {}; delete data.post.edited;
data.post.editor = null;
Object.keys(Diffs).forEach(function (property) { data.post.content = String(data.post.content || '');
Posts.diffs[property] = Diffs[property]; }
});
}; };

260
src/posts/edit.js
Unescape Escape View File

@ -1,6 +1,5 @@
'use strict'; 'use strict';
var async = require('async');
var validator = require('validator'); var validator = require('validator');
var _ = require('lodash'); var _ = require('lodash');
@ -19,161 +18,112 @@ module.exports = function (Posts) {
require('./cache').del(pid); require('./cache').del(pid);
}); });
Posts.edit = function (data, callback) { Posts.edit = async function (data) {
var oldContent; // for diffing purposes const canEdit = await privileges.posts.canEdit(data.pid, data.uid);
var postData; if (!canEdit.flag) {
var results; throw new Error(canEdit.message);
}
async.waterfall([ let postData = await Posts.getPostData(data.pid);
function (next) { if (!postData) {
privileges.posts.canEdit(data.pid, data.uid, next); throw new Error('[[error:no-post]]');
}, }
function (canEdit, next) {
if (!canEdit.flag) { const oldContent = postData.content; // for diffing purposes
return next(new Error(canEdit.message)); postData.content = data.content;
} postData.edited = Date.now();
Posts.getPostData(data.pid, next); postData.editor = data.uid;
}, if (data.handle) {
function (_postData, next) { postData.handle = data.handle;
if (!_postData) { }
return next(new Error('[[error:no-post]]')); const result = await plugins.fireHook('filter:post.edit', { req: data.req, post: postData, data: data, uid: data.uid });
} postData = result.post;
postData = _postData; const [editor, topic] = await Promise.all([
oldContent = postData.content; user.getUserFields(data.uid, ['username', 'userslug']),
postData.content = data.content; editMainPost(data, postData),
postData.edited = Date.now(); ]);
postData.editor = data.uid;
if (data.handle) { await Posts.setPostFields(data.pid, postData);
postData.handle = data.handle;
} if (meta.config.enablePostHistory === 1) {
plugins.fireHook('filter:post.edit', { req: data.req, post: postData, data: data, uid: data.uid }, next); await Posts.diffs.save(data.pid, oldContent, data.content);
}, }
function (result, next) { await Posts.uploads.sync(data.pid);
postData = result.post;
postData.cid = topic.cid;
async.parallel({ postData.topic = topic;
editor: function (next) { plugins.fireHook('action:post.edit', { post: _.clone(postData), data: data, uid: data.uid });
user.getUserFields(data.uid, ['username', 'userslug'], next);
}, require('./cache').del(String(postData.pid));
topic: function (next) { pubsub.publish('post:edit', String(postData.pid));
editMainPost(data, postData, next);
}, postData = await Posts.parsePost(postData);
}, next);
}, return {
function (_results, next) { topic: topic,
results = _results; editor: editor,
Posts.setPostFields(data.pid, postData, next); post: postData,
}, };
function (next) {
if (meta.config.enablePostHistory !== 1) {
return setImmediate(next);
}
Posts.diffs.save(data.pid, oldContent, data.content, next);
},
async.apply(Posts.uploads.sync, data.pid),
function (next) {
postData.cid = results.topic.cid;
postData.topic = results.topic;
plugins.fireHook('action:post.edit', { post: _.clone(postData), data: data, uid: data.uid });
require('./cache').del(String(postData.pid));
pubsub.publish('post:edit', String(postData.pid));
Posts.parsePost(postData, next);
},
function (postData, next) {
results.post = postData;
next(null, results);
},
], callback);
}; };
function editMainPost(data, postData, callback) { async function editMainPost(data, postData) {
var tid = postData.tid; const tid = postData.tid;
var title = data.title ? data.title.trim() : ''; const title = data.title ? data.title.trim() : '';
var topicData; const [topicData, isMain] = await Promise.all([
var results; topics.getTopicFields(tid, ['cid', 'title', 'timestamp']),
async.waterfall([ Posts.isMain(data.pid),
function (next) { ]);
async.parallel({
topic: function (next) { if (!isMain) {
topics.getTopicFields(tid, ['cid', 'title', 'timestamp'], next); return {
}, tid: tid,
isMain: function (next) { cid: topicData.cid,
Posts.isMain(data.pid, next); isMainPost: false,
}, renamed: false,
}, next); };
}, }
function (_results, next) {
results = _results; const newTopicData = {
if (!results.isMain) { tid: tid,
return callback(null, { cid: topicData.cid,
tid: tid, uid: postData.uid,
cid: results.topic.cid, mainPid: data.pid,
isMainPost: false, };
renamed: false, if (title) {
}); newTopicData.title = title;
} newTopicData.slug = tid + '/' + (utils.slugify(title) || 'topic');
}
topicData = { newTopicData.thumb = data.thumb || '';
tid: tid,
cid: results.topic.cid, data.tags = data.tags || [];
uid: postData.uid,
mainPid: data.pid, if (data.tags.length) {
}; const canTag = await privileges.categories.can('topics:tag', topicData.cid, data.uid);
if (!canTag) {
if (title) { throw new Error('[[error:no-privileges]]');
topicData.title = title; }
topicData.slug = tid + '/' + (utils.slugify(title) || 'topic'); }
} const results = await plugins.fireHook('filter:topic.edit', { req: data.req, topic: newTopicData, data: data });
await db.setObject('topic:' + tid, results.topic);
topicData.thumb = data.thumb || ''; await topics.updateTopicTags(tid, data.tags);
const tags = await topics.getTopicTagsObjects(tid);
data.tags = data.tags || [];
topicData.tags = data.tags;
if (!data.tags.length) { topicData.oldTitle = topicData.title;
return next(null, true); topicData.timestamp = topicData.timestamp;
} const renamed = translator.escape(validator.escape(String(title))) !== topicData.title;
plugins.fireHook('action:topic.edit', { topic: topicData, uid: data.uid });
privileges.categories.can('topics:tag', topicData.cid, data.uid, next); return {
}, tid: tid,
function (canTag, next) { cid: topicData.cid,
if (!canTag) { uid: postData.uid,
return next(new Error('[[error:no-privileges]]')); title: validator.escape(String(title)),
} oldTitle: topicData.title,
slug: topicData.slug,
plugins.fireHook('filter:topic.edit', { req: data.req, topic: topicData, data: data }, next); isMainPost: true,
}, renamed: renamed,
function (results, next) { tags: tags,
db.setObject('topic:' + tid, results.topic, next); };
},
function (next) {
topics.updateTopicTags(tid, data.tags, next);
},
function (next) {
topics.getTopicTagsObjects(tid, next);
},
function (tags, next) {
topicData.tags = data.tags;
topicData.oldTitle = results.topic.title;
topicData.timestamp = results.topic.timestamp;
var renamed = translator.escape(validator.escape(String(title))) !== results.topic.title;
plugins.fireHook('action:topic.edit', { topic: topicData, uid: data.uid });
next(null, {
tid: tid,
cid: topicData.cid,
uid: postData.uid,
title: validator.escape(String(title)),
oldTitle: results.topic.title,
slug: topicData.slug,
isMainPost: true,
renamed: renamed,
tags: tags,
});
},
], callback);
} }
}; };

Write Preview
Loading…
Cancel
Save