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

feat: #7743

Browse Source 
user/posts
user/profile
v1.18.x
Barış Soner Uşaklı 6 years ago
parent 0e8ee31b90
commit 6fea46b6e2
2 changed files with 232 additions and 368 deletions
Show Stats Download Patch File Download Diff File

136
src/user/posts.js
Unescape Escape View File

@ -1,113 +1,81 @@
'use strict'; 'use strict';
var async = require('async'); const db = require('../database');
var db = require('../database'); const meta = require('../meta');
var meta = require('../meta'); const privileges = require('../privileges');
var privileges = require('../privileges');
module.exports = function (User) { module.exports = function (User) {
User.isReadyToPost = function (uid, cid, callback) { User.isReadyToPost = async function (uid, cid) {
isReady(uid, cid, 'lastposttime', callback); await isReady(uid, cid, 'lastposttime');
}; };
User.isReadyToQueue = function (uid, cid, callback) { User.isReadyToQueue = async function (uid, cid) {
isReady(uid, cid, 'lastqueuetime', callback); await isReady(uid, cid, 'lastqueuetime');
}; };
function isReady(uid, cid, field, callback) { async function isReady(uid, cid, field) {
if (parseInt(uid, 10) === 0) { if (parseInt(uid, 10) === 0) {
return callback(); return;
} }
async.waterfall([ const [userData, isAdminOrMod] = await Promise.all([
function (next) { User.getUserFields(uid, ['uid', 'banned', 'joindate', 'email', 'email:confirmed', 'reputation'].concat([field])),
async.parallel({ privileges.categories.isAdminOrMod(cid, uid),
userData: function (next) { ]);
User.getUserFields(uid, ['uid', 'banned', 'joindate', 'email', 'email:confirmed', 'reputation'].concat([field]), next);
},
isAdminOrMod: function (next) {
privileges.categories.isAdminOrMod(cid, uid, next);
},
}, next);
},
function (results, next) {
if (!results.userData.uid) {
return next(new Error('[[error:no-user]]'));
}
if (results.isAdminOrMod) { if (!userData.uid) {
return next(); throw new Error('[[error:no-user]]');
} }
var userData = results.userData;
if (userData.banned) { if (isAdminOrMod) {
return next(new Error('[[error:user-banned]]')); return;
} }
if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) { if (userData.banned) {
return next(new Error('[[error:email-not-confirmed]]')); throw new Error('[[error:user-banned]]');
} }
var now = Date.now(); if (meta.config.requireEmailConfirmation && !userData['email:confirmed']) {
if (now - userData.joindate < meta.config.initialPostDelay * 1000) { throw new Error('[[error:email-not-confirmed]]');
return next(new Error('[[error:user-too-new, ' + meta.config.initialPostDelay + ']]')); }
}
var lasttime = userData[field] || 0; var now = Date.now();
if (now - userData.joindate < meta.config.initialPostDelay * 1000) {
throw new Error('[[error:user-too-new, ' + meta.config.initialPostDelay + ']]');
}
if (meta.config.newbiePostDelay > 0 && meta.config.newbiePostDelayThreshold > userData.reputation && now - lasttime < meta.config.newbiePostDelay * 1000) { var lasttime = userData[field] || 0;
return next(new Error('[[error:too-many-posts-newbie, ' + meta.config.newbiePostDelay + ', ' + meta.config.newbiePostDelayThreshold + ']]'));
} else if (now - lasttime < meta.config.postDelay * 1000) {
return next(new Error('[[error:too-many-posts, ' + meta.config.postDelay + ']]'));
}
next(); if (meta.config.newbiePostDelay > 0 && meta.config.newbiePostDelayThreshold > userData.reputation && now - lasttime < meta.config.newbiePostDelay * 1000) {
}, throw new Error('[[error:too-many-posts-newbie, ' + meta.config.newbiePostDelay + ', ' + meta.config.newbiePostDelayThreshold + ']]');
], callback); } else if (now - lasttime < meta.config.postDelay * 1000) {
throw new Error('[[error:too-many-posts, ' + meta.config.postDelay + ']]');
}
} }
User.onNewPostMade = function (postData, callback) { User.onNewPostMade = async function (postData) {
async.series([ await User.addPostIdToUser(postData);
function (next) { await User.incrementUserPostCountBy(postData.uid, 1);
User.addPostIdToUser(postData, next); await User.setUserField(postData.uid, 'lastposttime', postData.timestamp);
}, await User.updateLastOnlineTime(postData.uid);
function (next) {
User.incrementUserPostCountBy(postData.uid, 1, next);
},
function (next) {
User.setUserField(postData.uid, 'lastposttime', postData.timestamp, next);
},
function (next) {
User.updateLastOnlineTime(postData.uid, next);
},
], callback);
}; };
User.addPostIdToUser = function (postData, callback) { User.addPostIdToUser = async function (postData) {
db.sortedSetsAdd([ await db.sortedSetsAdd([
'uid:' + postData.uid + ':posts', 'uid:' + postData.uid + ':posts',
'cid:' + postData.cid + ':uid:' + postData.uid + ':pids', 'cid:' + postData.cid + ':uid:' + postData.uid + ':pids',
], postData.timestamp, postData.pid, callback); ], postData.timestamp, postData.pid);
}; };
User.incrementUserPostCountBy = function (uid, value, callback) { User.incrementUserPostCountBy = async function (uid, value) {
callback = callback || function () {}; const newpostcount = await User.incrementUserFieldBy(uid, 'postcount', value);
async.waterfall([ if (parseInt(uid, 10) <= 0) {
function (next) { return;
User.incrementUserFieldBy(uid, 'postcount', value, next); }
}, await db.sortedSetAdd('users:postcount', newpostcount, uid);
function (newpostcount, next) {
if (parseInt(uid, 10) <= 0) {
return next();
}
db.sortedSetAdd('users:postcount', newpostcount, uid, next);
},
], callback);
}; };
User.getPostIds = function (uid, start, stop, callback) { User.getPostIds = async function (uid, start, stop) {
db.getSortedSetRevRange('uid:' + uid + ':posts', start, stop, function (err, pids) { const pids = await db.getSortedSetRevRange('uid:' + uid + ':posts', start, stop);
callback(err, Array.isArray(pids) ? pids : []); return Array.isArray(pids) ? pids : [];
});
}; };
}; };

464
src/user/profile.js
Unescape Escape View File

@ -10,350 +10,246 @@ var groups = require('../groups');
var plugins = require('../plugins'); var plugins = require('../plugins');
module.exports = function (User) { module.exports = function (User) {
User.updateProfile = function (uid, data, callback) { User.updateProfile = async function (uid, data) {
var fields = ['username', 'email', 'fullname', 'website', 'location', var fields = ['username', 'email', 'fullname', 'website', 'location',
'groupTitle', 'birthday', 'signature', 'aboutme']; 'groupTitle', 'birthday', 'signature', 'aboutme'];
var updateUid = data.uid; var updateUid = data.uid;
var oldData;
async.waterfall([
function (next) {
plugins.fireHook('filter:user.updateProfile', { uid: uid, data: data, fields: fields }, next);
},
function (data, next) {
fields = data.fields;
data = data.data;
validateData(uid, data, next);
},
function (next) {
User.getUserFields(updateUid, fields, next);
},
function (_oldData, next) {
oldData = _oldData;
async.each(fields, function (field, next) {
if (!(data[field] !== undefined && typeof data[field] === 'string')) {
return next();
}
data[field] = data[field].trim();
if (field === 'email') {
return updateEmail(updateUid, data.email, next);
} else if (field === 'username') {
return updateUsername(updateUid, data.username, next);
} else if (field === 'fullname') {
return updateFullname(updateUid, data.fullname, next);
}
User.setUserField(updateUid, field, data[field], next);
}, next);
},
function (next) {
plugins.fireHook('action:user.updateProfile', { uid: uid, data: data, fields: fields, oldData: oldData });
User.getUserFields(updateUid, ['email', 'username', 'userslug', 'picture', 'icon:text', 'icon:bgColor'], next);
},
], callback);
};
function validateData(callerUid, data, callback) { const result = await plugins.fireHook('filter:user.updateProfile', { uid: uid, data: data, fields: fields });
async.series([ fields = result.fields;
async.apply(isEmailAvailable, data, data.uid), data = result.data;
async.apply(isUsernameAvailable, data, data.uid),
async.apply(isGroupTitleValid, data), await validateData(uid, data);
async.apply(isWebsiteValid, callerUid, data),
async.apply(isAboutMeValid, callerUid, data), const oldData = await User.getUserFields(updateUid, fields);
async.apply(isSignatureValid, callerUid, data),
], function (err) { await async.each(fields, async function (field) {
callback(err); if (!(data[field] !== undefined && typeof data[field] === 'string')) {
return;
}
data[field] = data[field].trim();
if (field === 'email') {
return await updateEmail(updateUid, data.email);
} else if (field === 'username') {
return await updateUsername(updateUid, data.username);
} else if (field === 'fullname') {
return await updateFullname(updateUid, data.fullname);
}
await User.setUserField(updateUid, field, data[field]);
}); });
plugins.fireHook('action:user.updateProfile', { uid: uid, data: data, fields: fields, oldData: oldData });
return await User.getUserFields(updateUid, ['email', 'username', 'userslug', 'picture', 'icon:text', 'icon:bgColor']);
};
async function validateData(callerUid, data) {
await isEmailAvailable(data, data.uid);
await isUsernameAvailable(data, data.uid);
await isWebsiteValid(callerUid, data);
await isAboutMeValid(callerUid, data);
await isSignatureValid(callerUid, data);
isGroupTitleValid(data);
} }
function isEmailAvailable(data, uid, callback) { async function isEmailAvailable(data, uid) {
if (!data.email) { if (!data.email) {
return callback(); return;
} }
if (!utils.isEmailValid(data.email)) { if (!utils.isEmailValid(data.email)) {
return callback(new Error('[[error:invalid-email]]')); throw new Error('[[error:invalid-email]]');
}
const email = await User.getUserField(uid, 'email');
if (email === data.email) {
return;
}
const available = await User.email.available(data.email);
if (!available) {
throw new Error('[[error:email-taken]]');
} }
async.waterfall([
function (next) {
User.getUserField(uid, 'email', next);
},
function (email, next) {
if (email === data.email) {
return callback();
}
User.email.available(data.email, next);
},
function (available, next) {
next(!available ? new Error('[[error:email-taken]]') : null);
},
], callback);
} }
function isUsernameAvailable(data, uid, callback) { async function isUsernameAvailable(data, uid) {
if (!data.username) { if (!data.username) {
return callback(); return;
} }
data.username = data.username.trim(); data.username = data.username.trim();
async.waterfall([ const userData = await User.getUserFields(uid, ['username', 'userslug']);
function (next) { var userslug = utils.slugify(data.username);
User.getUserFields(uid, ['username', 'userslug'], next);
}, if (data.username.length < meta.config.minimumUsernameLength) {
function (userData, next) { throw new Error('[[error:username-too-short]]');
var userslug = utils.slugify(data.username); }
if (data.username.length < meta.config.minimumUsernameLength) { if (data.username.length > meta.config.maximumUsernameLength) {
return next(new Error('[[error:username-too-short]]')); throw new Error('[[error:username-too-long]]');
} }
if (data.username.length > meta.config.maximumUsernameLength) { if (!utils.isUserNameValid(data.username) || !userslug) {
return next(new Error('[[error:username-too-long]]')); throw new Error('[[error:invalid-username]]');
} }
if (!utils.isUserNameValid(data.username) || !userslug) { if (userslug === userData.userslug) {
return next(new Error('[[error:invalid-username]]')); return;
} }
const exists = await User.existsBySlug(userslug);
if (userslug === userData.userslug) { if (exists) {
return callback(); throw new Error('[[error:username-taken]]');
} }
User.existsBySlug(userslug, next);
},
function (exists, next) {
next(exists ? new Error('[[error:username-taken]]') : null);
},
], callback);
} }
function isGroupTitleValid(data, callback) { function isGroupTitleValid(data) {
if (data.groupTitle === 'registered-users' || groups.isPrivilegeGroup(data.groupTitle)) { if (data.groupTitle === 'registered-users' || groups.isPrivilegeGroup(data.groupTitle)) {
callback(new Error('[[error:invalid-group-title]]')); throw new Error('[[error:invalid-group-title]]');
} else {
callback();
} }
} }
function isWebsiteValid(callerUid, data, callback) { async function isWebsiteValid(callerUid, data) {
if (!data.website) { if (!data.website) {
return setImmediate(callback); return;
} }
User.checkMinReputation(callerUid, data.uid, 'min:rep:website', callback); await User.checkMinReputation(callerUid, data.uid, 'min:rep:website');
} }
function isAboutMeValid(callerUid, data, callback) { async function isAboutMeValid(callerUid, data) {
if (!data.aboutme) { if (!data.aboutme) {
return setImmediate(callback); return;
} }
if (data.aboutme !== undefined && data.aboutme.length > meta.config.maximumAboutMeLength) { if (data.aboutme !== undefined && data.aboutme.length > meta.config.maximumAboutMeLength) {
return callback(new Error('[[error:about-me-too-long, ' + meta.config.maximumAboutMeLength + ']]')); throw new Error('[[error:about-me-too-long, ' + meta.config.maximumAboutMeLength + ']]');
} }
User.checkMinReputation(callerUid, data.uid, 'min:rep:aboutme', callback); await User.checkMinReputation(callerUid, data.uid, 'min:rep:aboutme');
} }
function isSignatureValid(callerUid, data, callback) { async function isSignatureValid(callerUid, data) {
if (!data.signature) { if (!data.signature) {
return setImmediate(callback); return;
} }
if (data.signature !== undefined && data.signature.length > meta.config.maximumSignatureLength) { if (data.signature !== undefined && data.signature.length > meta.config.maximumSignatureLength) {
return callback(new Error('[[error:signature-too-long, ' + meta.config.maximumSignatureLength + ']]')); throw new Error('[[error:signature-too-long, ' + meta.config.maximumSignatureLength + ']]');
} }
User.checkMinReputation(callerUid, data.uid, 'min:rep:signature', callback); await User.checkMinReputation(callerUid, data.uid, 'min:rep:signature');
} }
User.checkMinReputation = function (callerUid, uid, setting, callback) { User.checkMinReputation = async function (callerUid, uid, setting) {
var isSelf = parseInt(callerUid, 10) === parseInt(uid, 10); var isSelf = parseInt(callerUid, 10) === parseInt(uid, 10);
if (!isSelf || meta.config['reputation:disabled']) { if (!isSelf || meta.config['reputation:disabled']) {
return setImmediate(callback); return;
}
const reputation = await User.getUserField(uid, 'reputation');
if (reputation < meta.config[setting]) {
throw new Error('[[error:not-enough-reputation-' + setting.replace(/:/g, '-') + ']]');
} }
async.waterfall([
function (next) {
User.getUserField(uid, 'reputation', next);
},
function (reputation, next) {
if (reputation < meta.config[setting]) {
return next(new Error('[[error:not-enough-reputation-' + setting.replace(/:/g, '-') + ']]'));
}
next();
},
], callback);
}; };
function updateEmail(uid, newEmail, callback) { async function updateEmail(uid, newEmail) {
async.waterfall([ let oldEmail = await User.getUserField(uid, 'email');
function (next) { oldEmail = oldEmail || '';
User.getUserField(uid, 'email', next); if (oldEmail === newEmail) {
}, return;
function (oldEmail, next) { }
oldEmail = oldEmail || '';
await db.sortedSetRemove('email:uid', oldEmail.toLowerCase());
if (oldEmail === newEmail) { await db.sortedSetRemove('email:sorted', oldEmail.toLowerCase() + ':' + uid);
return callback(); await User.auth.revokeAllSessions(uid);
}
async.series([ await Promise.all([
async.apply(db.sortedSetRemove, 'email:uid', oldEmail.toLowerCase()), db.sortedSetAddBulk([
async.apply(db.sortedSetRemove, 'email:sorted', oldEmail.toLowerCase() + ':' + uid), ['email:uid', uid, newEmail.toLowerCase()],
async.apply(User.auth.revokeAllSessions, uid), ['email:sorted', 0, newEmail.toLowerCase() + ':' + uid],
], function (err) { ['user:' + uid + ':emails', Date.now(), newEmail + ':' + Date.now()],
next(err); ['users:notvalidated', Date.now(), uid],
}); ]),
}, User.setUserFields(uid, { email: newEmail, 'email:confirmed': 0 }),
function (next) { User.reset.cleanByUid(uid),
async.parallel([ ]);
function (next) {
db.sortedSetAddBulk([ if (meta.config.requireEmailConfirmation && newEmail) {
['email:uid', uid, newEmail.toLowerCase()], User.email.sendValidationEmail(uid, {
['email:sorted', 0, newEmail.toLowerCase() + ':' + uid], email: newEmail,
['user:' + uid + ':emails', Date.now(), newEmail + ':' + Date.now()], subject: '[[email:email.verify-your-email.subject]]',
['users:notvalidated', Date.now(), uid], template: 'verify_email',
], next); });
}, }
function (next) {
User.setUserField(uid, 'email', newEmail, next);
},
function (next) {
if (meta.config.requireEmailConfirmation && newEmail) {
User.email.sendValidationEmail(uid, {
email: newEmail,
subject: '[[email:email.verify-your-email.subject]]',
template: 'verify_email',
});
}
User.setUserField(uid, 'email:confirmed', 0, next);
},
function (next) {
User.reset.cleanByUid(uid, next);
},
], function (err) {
next(err);
});
},
], callback);
} }
function updateUsername(uid, newUsername, callback) { async function updateUsername(uid, newUsername) {
if (!newUsername) { if (!newUsername) {
return setImmediate(callback); return;
} }
const userData = await User.getUserFields(uid, ['username', 'userslug']);
async.waterfall([ if (userData.username === newUsername) {
function (next) { return;
User.getUserFields(uid, ['username', 'userslug'], next); }
}, const newUserslug = utils.slugify(newUsername);
function (userData, next) { const now = Date.now();
if (userData.username === newUsername) { await Promise.all([
return callback(); updateUidMapping('username', uid, newUsername, userData.username),
} updateUidMapping('userslug', uid, newUserslug, userData.userslug),
async.parallel([ db.sortedSetAdd('user:' + uid + ':usernames', now, newUsername + ':' + now),
function (next) { ]);
updateUidMapping('username', uid, newUsername, userData.username, next); await db.sortedSetRemove('username:sorted', userData.username.toLowerCase() + ':' + uid);
}, await db.sortedSetAdd('username:sorted', 0, newUsername.toLowerCase() + ':' + uid);
function (next) {
var newUserslug = utils.slugify(newUsername);
updateUidMapping('userslug', uid, newUserslug, userData.userslug, next);
},
function (next) {
var now = Date.now();
async.series([
async.apply(db.sortedSetRemove, 'username:sorted', userData.username.toLowerCase() + ':' + uid),
async.apply(db.sortedSetAdd, 'username:sorted', 0, newUsername.toLowerCase() + ':' + uid),
async.apply(db.sortedSetAdd, 'user:' + uid + ':usernames', now, newUsername + ':' + now),
], next);
},
], next);
},
], function (err) {
callback(err);
});
} }
function updateUidMapping(field, uid, value, oldValue, callback) { async function updateUidMapping(field, uid, value, oldValue) {
if (value === oldValue) { if (value === oldValue) {
return callback(); return;
}
await db.sortedSetRemove(field + ':uid', oldValue);
await User.setUserField(uid, field, value);
if (value) {
await db.sortedSetAdd(field + ':uid', uid, value);
} }
async.series([
function (next) {
db.sortedSetRemove(field + ':uid', oldValue, next);
},
function (next) {
User.setUserField(uid, field, value, next);
},
function (next) {
if (value) {
db.sortedSetAdd(field + ':uid', uid, value, next);
} else {
next();
}
},
], callback);
} }
function updateFullname(uid, newFullname, callback) { async function updateFullname(uid, newFullname) {
async.waterfall([ const fullname = await User.getUserField(uid, 'fullname');
function (next) { await updateUidMapping('fullname', uid, newFullname, fullname);
User.getUserField(uid, 'fullname', next);
},
function (fullname, next) {
updateUidMapping('fullname', uid, newFullname, fullname, next);
},
], callback);
} }
User.changePassword = function (uid, data, callback) { User.changePassword = async function (uid, data) {
if (uid <= 0 || !data || !data.uid) { if (uid <= 0 || !data || !data.uid) {
return callback(new Error('[[error:invalid-uid]]')); throw new Error('[[error:invalid-uid]]');
}
await User.isPasswordValid(data.newPassword);
const [isAdmin, hasPassword] = await Promise.all([
User.isAdministrator(uid),
User.hasPassword(uid),
]);
if (meta.config['password:disableEdit'] && !isAdmin) {
throw new Error('[[error:no-privileges]]');
}
let isAdminOrPasswordMatch = false;
const isSelf = parseInt(uid, 10) === parseInt(data.uid, 10);
if (
(isAdmin && !isSelf) || // Admins ok
(!hasPassword && isSelf) // Initial password set ok
) {
isAdminOrPasswordMatch = true;
} else {
isAdminOrPasswordMatch = await User.isPasswordCorrect(uid, data.currentPassword, data.ip);
}
if (!isAdminOrPasswordMatch) {
throw new Error('[[user:change_password_error_wrong_current]]');
} }
async.waterfall([ const hashedPassword = await User.hashPassword(data.newPassword);
function (next) { await Promise.all([
User.isPasswordValid(data.newPassword, next); User.setUserFields(data.uid, {
}, password: hashedPassword,
function (next) { rss_token: utils.generateUUID(),
async.parallel({ }),
isAdmin: async.apply(User.isAdministrator, uid), User.reset.updateExpiry(data.uid),
hasPassword: async.apply(User.hasPassword, uid), User.auth.revokeAllSessions(data.uid),
}, next); ]);
},
function (checks, next) { plugins.fireHook('action:password.change', { uid: uid });
if (meta.config['password:disableEdit'] && !checks.isAdmin) {
return next(new Error('[[error:no-privileges]]'));
}
if (
(checks.isAdmin && parseInt(uid, 10) !== parseInt(data.uid, 10)) || // Admins ok
(!checks.hasPassword && parseInt(uid, 10) === parseInt(data.uid, 10)) // Initial password set ok
) {
return next(null, true);
}
User.isPasswordCorrect(uid, data.currentPassword, data.ip, next);
},
function (isAdminOrPasswordMatch, next) {
if (!isAdminOrPasswordMatch) {
return next(new Error('[[user:change_password_error_wrong_current]]'));
}
User.hashPassword(data.newPassword, next);
},
function (hashedPassword, next) {
async.parallel([
async.apply(User.setUserFields, data.uid, {
password: hashedPassword,
rss_token: utils.generateUUID(),
}),
async.apply(User.reset.updateExpiry, data.uid),
async.apply(User.auth.revokeAllSessions, data.uid),
async.apply(plugins.fireHook, 'action:password.change', { uid: uid }),
], function (err) {
next(err);
});
},
], callback);
}; };
}; };

Write Preview
Loading…
Cancel
Save