mirrors/etherpad-lite
1
0
Fork 0
mirror of https://github.com/ether/etherpad-lite.git synced 2025-04-21 07:56:16 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

db/GroupManager.js: mostly converted to Promises / async

Browse source
This commit is contained in:
Ray Bellis 2019-01-25 12:56:57 +00:00
parent 29e9f86cad
commit 70a045ad3c
1 changed files with 102 additions and 239 deletions
Download patch file Download diff file Expand all files Collapse all files

271
src/node/db/GroupManager.js
View file

@ -21,113 +21,57 @@
var ERR = require("async-stacktrace"); var ERR = require("async-stacktrace");
var customError = require("../utils/customError"); var customError = require("../utils/customError");
var randomString = require('ep_etherpad-lite/static/js/pad_utils').randomString; var randomString = require('ep_etherpad-lite/static/js/pad_utils').randomString;
var db = require("./DB").db; var db = require("./DB");
var async = require("async");
var padManager = require("./PadManager"); var padManager = require("./PadManager");
var sessionManager = require("./SessionManager"); var sessionManager = require("./SessionManager");
const thenify = require("thenify").withCallback; const thenify = require("thenify").withCallback;
exports.listAllGroups = thenify(function(callback) { exports.listAllGroups = async function()
db.get("groups", function (err, groups) {
if (ERR(err, callback)) return;
if (groups == null) {
// there are no groups
callback(null, {groupIDs: []});
return;
}
var groupIDs = [];
for (var groupID in groups) {
groupIDs.push(groupID);
}
callback(null, {groupIDs: groupIDs});
});
});
exports.deleteGroup = thenify(function(groupID, callback)
{ {
var group; let groups = await db.get("groups");
groups = groups || {};
async.series([ let groupIDs = Object.keys(groups);
// ensure group exists return { groupIDs };
function (callback) {
// try to get the group entry
db.get("group:" + groupID, function (err, _group) {
if (ERR(err, callback)) return;
if (_group == null) {
// group does not exist
callback(new customError("groupID does not exist", "apierror"));
return;
} }
// group exists, everything is fine exports.deleteGroup = async function(groupID)
group = _group; {
callback(); let group = await db.get("group:" + groupID);
});
}, // ensure group exists
if (group == null) {
// group does not exist
throw new customError("groupID does not exist", "apierror");
}
// iterate through all pads of this group and delete them // iterate through all pads of this group and delete them
function(callback) { for (let padID in group.pads) {
// collect all padIDs in an array, that allows us to use async.forEach let pad = await padManager.getPad(padID);
var padIDs = []; await pad.remove();
for(var i in group.pads) {
padIDs.push(i);
} }
// loop through all pads and delete them
async.forEach(padIDs, function(padID, callback) {
padManager.getPad(padID, function(err, pad) {
if (ERR(err, callback)) return;
pad.remove(callback);
});
}, callback);
},
// iterate through group2sessions and delete all sessions // iterate through group2sessions and delete all sessions
function(callback) let group2sessions = await db.get("group2sessions:" + groupID);
{ let sessions = group2sessions ? group2sessions.sessionsIDs : [];
// try to get the group entry
db.get("group2sessions:" + groupID, function (err, group2sessions) {
if (ERR(err, callback)) return;
// skip if there is no group2sessions entry
if (group2sessions == null) { callback(); return }
// collect all sessions in an array, that allows us to use async.forEach
var sessions = [];
for (var i in group2sessions.sessionsIDs) {
sessions.push(i);
}
// loop through all sessions and delete them // loop through all sessions and delete them
async.forEach(sessions, function(session, callback) { for (let session in sessions) {
sessionManager.deleteSession(session, callback); await sessionManager.deleteSession(session);
}, callback); }
});
},
// remove group and group2sessions entry // remove group and group2sessions entry
function(callback) { await db.remove("group2sessions:" + groupID);
db.remove("group2sessions:" + groupID); await db.remove("group:" + groupID);
db.remove("group:" + groupID);
callback();
},
// unlist the group // unlist the group
function(callback) { let groups = await exports.listAllGroups();
exports.listAllGroups(function(err, groups) {
if (ERR(err, callback)) return;
groups = groups ? groups.groupIDs : []; groups = groups ? groups.groupIDs : [];
let index = groups.indexOf(groupID); let index = groups.indexOf(groupID);
if (index === -1) { if (index === -1) {
// it's not listed // it's not listed
callback();
return; return;
} }
@ -135,191 +79,110 @@ exports.deleteGroup = thenify(function(groupID, callback)
// remove from the list // remove from the list
groups.splice(index, 1); groups.splice(index, 1);
// store empty group list
if (groups.length == 0) {
db.set("groups", {});
callback();
return;
}
// regenerate group list // regenerate group list
var newGroups = {}; var newGroups = {};
async.forEach(groups, function(group, cb) { groups.forEach(group => newGroups[group] = 1);
newGroups[group] = 1; await db.set("groups", newGroups);
cb();
},
function() {
db.set("groups", newGroups);
callback();
});
});
} }
],
function(err) {
if (ERR(err, callback)) return;
callback();
});
});
// @TODO: this is the only function still called with a callback
exports.doesGroupExist = thenify(function(groupID, callback) exports.doesGroupExist = thenify(function(groupID, callback)
{ {
// try to get the group entry // try to get the group entry
db.get("group:" + groupID, function (err, group) { db.db.get("group:" + groupID, function (err, group) {
if (ERR(err, callback)) return; if (ERR(err, callback)) return;
callback(null, group != null); callback(null, group != null);
}); });
}); });
exports.createGroup = thenify(function(callback) exports.createGroup = async function()
{ {
// search for non existing groupID // search for non existing groupID
var groupID = "g." + randomString(16); var groupID = "g." + randomString(16);
// create the group // create the group
db.set("group:" + groupID, {pads: {}}); await db.set("group:" + groupID, {pads: {}});
// list the group // list the group
exports.listAllGroups(function(err, groups) { let groups = await exports.listAllGroups();
if (ERR(err, callback)) return;
groups = groups? groups.groupIDs : []; groups = groups? groups.groupIDs : [];
groups.push(groupID); groups.push(groupID);
// regenerate group list // regenerate group list
var newGroups = {}; var newGroups = {};
async.forEach(groups, function(group, cb) { groups.forEach(group => newGroups[group] = 1);
newGroups[group] = 1; await db.set("groups", newGroups);
cb();
},
function() {
db.set("groups", newGroups);
callback(null, {groupID: groupID});
});
});
});
exports.createGroupIfNotExistsFor = thenify(function(groupMapper, callback) return { groupID };
}
exports.createGroupIfNotExistsFor = async function(groupMapper)
{ {
// ensure mapper is optional // ensure mapper is optional
if (typeof groupMapper !== "string") { if (typeof groupMapper !== "string") {
callback(new customError("groupMapper is not a string", "apierror")); throw new customError("groupMapper is not a string", "apierror");
return;
} }
// try to get a group for this mapper // try to get a group for this mapper
db.get("mapper2group:" + groupMapper, function(err, groupID) { let groupID = await db.get("mapper2group:" + groupMapper);
function createGroupForMapper(cb) {
exports.createGroup(function(err, responseObj) {
if (ERR(err, cb)) return;
// create the mapper entry for this group
db.set("mapper2group:" + groupMapper, responseObj.groupID);
cb(null, responseObj);
});
}
if (ERR(err, callback)) return;
if (groupID) { if (groupID) {
// there is a group for this mapper // there is a group for this mapper
exports.doesGroupExist(groupID, function(err, exists) { let exists = await exports.doesGroupExist(groupID);
if (ERR(err, callback)) return;
if (exists) return callback(null, {groupID: groupID}); if (exists) return { groupID };
}
// hah, the returned group doesn't exist, let's create one // hah, the returned group doesn't exist, let's create one
createGroupForMapper(callback) let result = await exports.createGroup();
});
return; // create the mapper entry for this group
await db.set("mapper2group:" + groupMapper, result.groupID);
return result;
} }
// there is no group for this mapper, let's create a group exports.createGroupPad = async function(groupID, padName, text)
createGroupForMapper(callback)
});
});
exports.createGroupPad = thenify(function(groupID, padName, text, callback)
{ {
// create the padID // create the padID
var padID = groupID + "$" + padName; let padID = groupID + "$" + padName;
async.series([
// ensure group exists // ensure group exists
function (callback) { let groupExists = await exports.doesGroupExist(groupID);
exports.doesGroupExist(groupID, function(err, exists) {
if (ERR(err, callback)) return;
if (!exists) { if (!groupExists) {
// group does not exist throw new customError("groupID does not exist", "apierror");
callback(new customError("groupID does not exist", "apierror"));
return;
} }
// group exists, everything is fine
callback();
});
},
// ensure pad doesn't exist already // ensure pad doesn't exist already
function (callback) { let padExists = await padManager.doesPadExists(padID);
padManager.doesPadExists(padID, function(err, exists) {
if (ERR(err, callback)) return;
if (exists == true) { if (padExists) {
// pad exists already // pad exists already
callback(new customError("padName does already exist", "apierror")); throw new customError("padName does already exist", "apierror");
return;
} }
// pad does not exist, everything is fine
callback();
});
},
// create the pad // create the pad
function (callback) { await padManager.getPad(padID, text);
padManager.getPad(padID, text, function(err) {
if (ERR(err, callback)) return;
callback();
});
},
//create an entry in the group for this pad //create an entry in the group for this pad
function (callback) { await db.setSub("group:" + groupID, ["pads", padID], 1);
db.setSub("group:" + groupID, ["pads", padID], 1);
callback(); return { padID };
} }
],
function(err) {
if (ERR(err, callback)) return;
callback(null, {padID: padID}); exports.listPads = async function(groupID)
});
});
exports.listPads = thenify(function(groupID, callback)
{ {
exports.doesGroupExist(groupID, function(err, exists) { let exists = await exports.doesGroupExist(groupID);
if (ERR(err, callback)) return;
// ensure the group exists // ensure the group exists
if (!exists) { if (!exists) {
callback(new customError("groupID does not exist", "apierror")); throw new customError("groupID does not exist", "apierror");
return;
} }
// group exists, let's get the pads // group exists, let's get the pads
db.getSub("group:" + groupID, ["pads"], function(err, result) { let result = await db.getSub("group:" + groupID, ["pads"]);
if (ERR(err, callback)) return; let padIDs = Object.keys(result);
var pads = []; return { padIDs };
for ( var padId in result ) {
pads.push(padId);
} }
callback(null, {padIDs: pads});
});
});
});