511 lines
11 KiB
JavaScript
Executable File
511 lines
11 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
|
|
/* jslint node: true */
|
|
/* eslint-disable no-console */
|
|
'use strict';
|
|
|
|
// ENiGMA½
|
|
const config = require('./core/config.js');
|
|
const db = require('./core/database.js');
|
|
const resolvePath = require('./core/misc_util.js').resolvePath;
|
|
|
|
// deps
|
|
const _ = require('lodash');
|
|
const async = require('async');
|
|
const inq = require('inquirer');
|
|
const mkdirsSync = require('fs-extra').mkdirsSync;
|
|
const fs = require('fs');
|
|
const hjson = require('hjson');
|
|
const paths = require('path');
|
|
|
|
const argv = require('minimist')(process.argv.slice(2));
|
|
|
|
const ExitCodes = {
|
|
SUCCESS : 0,
|
|
ERROR : -1,
|
|
BAD_COMMAND : -2,
|
|
BAD_ARGS : -3,
|
|
};
|
|
|
|
const USAGE_HELP = {
|
|
General :
|
|
`usage: optutil.js [--version] [--help]
|
|
<command> [<args>]
|
|
|
|
global args:
|
|
--config PATH : specify config path (${getDefaultConfigPath()})
|
|
|
|
commands:
|
|
user : user utilities
|
|
config : config file management
|
|
file-area : file area management
|
|
|
|
`,
|
|
User :
|
|
`usage: optutil.js user --user USERNAME <args>
|
|
|
|
valid args:
|
|
--user USERNAME : specify username for further actions
|
|
--password PASS : set new password
|
|
--delete : delete user
|
|
--activate : activate user
|
|
--deactivate : deactivate user
|
|
`,
|
|
|
|
Config :
|
|
`usage: optutil.js config <args>
|
|
|
|
valid args:
|
|
--new : generate a new/initial configuration
|
|
`,
|
|
FileArea :
|
|
`usage: oputil.js file-area <args>
|
|
|
|
valid args:
|
|
--scan AREA_TAG : (re)scan area specified by AREA_TAG for new files
|
|
`
|
|
};
|
|
|
|
function printUsageAndSetExitCode(command, exitCode) {
|
|
if(_.isUndefined(exitCode)) {
|
|
exitCode = ExitCodes.ERROR;
|
|
}
|
|
process.exitCode = exitCode;
|
|
const errMsg = USAGE_HELP[command];
|
|
if(errMsg) {
|
|
console.error(errMsg);
|
|
}
|
|
}
|
|
|
|
function initConfig(cb) {
|
|
const configPath = argv.config ? argv.config : config.getDefaultPath();
|
|
|
|
config.init(configPath, cb);
|
|
}
|
|
|
|
function initConfigAndDatabases(cb) {
|
|
async.series(
|
|
[
|
|
function init(callback) {
|
|
initConfig(callback);
|
|
},
|
|
function initDb(callback) {
|
|
db.initializeDatabases(callback);
|
|
},
|
|
],
|
|
err => {
|
|
return cb(err);
|
|
}
|
|
);
|
|
}
|
|
|
|
function getUser(userName, cb) {
|
|
const user = require('./core/user.js');
|
|
user.getUserIdAndName(argv.user, function userNameAndId(err, userId) {
|
|
if(err) {
|
|
process.exitCode = ExitCodes.BAD_ARGS;
|
|
return cb(new Error('Failed to retrieve user'));
|
|
} else {
|
|
let u = new user.User();
|
|
u.userId = userId;
|
|
return cb(null, u);
|
|
}
|
|
});
|
|
}
|
|
|
|
function initAndGetUser(userName, cb) {
|
|
async.waterfall(
|
|
[
|
|
function init(callback) {
|
|
initConfigAndDatabases(callback);
|
|
},
|
|
function getUserObject(callback) {
|
|
getUser(argv.user, (err, user) => {
|
|
if(err) {
|
|
process.exitCode = ExitCodes.BAD_ARGS;
|
|
return callback(err);
|
|
}
|
|
return callback(null, user);
|
|
});
|
|
}
|
|
],
|
|
(err, user) => {
|
|
return cb(err, user);
|
|
}
|
|
);
|
|
}
|
|
|
|
function setAccountStatus(userName, active) {
|
|
async.waterfall(
|
|
[
|
|
function init(callback) {
|
|
initAndGetUser(argv.user, callback);
|
|
},
|
|
function activateUser(user, callback) {
|
|
const AccountStatus = require('./core/user.js').User.AccountStatus;
|
|
user.persistProperty('account_status', active ? AccountStatus.active : AccountStatus.inactive, callback);
|
|
}
|
|
],
|
|
err => {
|
|
if(err) {
|
|
console.error(err.message);
|
|
} else {
|
|
console.info('User ' + ((true === active) ? 'activated' : 'deactivated'));
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
function handleUserCommand() {
|
|
if(true === argv.help || !_.isString(argv.user) || 0 === argv.user.length) {
|
|
return printUsageAndSetExitCode('User', ExitCodes.ERROR);
|
|
}
|
|
|
|
if(_.isString(argv.password)) {
|
|
if(0 === argv.password.length) {
|
|
process.exitCode = ExitCodes.BAD_ARGS;
|
|
return console.error('Invalid password');
|
|
}
|
|
|
|
async.waterfall(
|
|
[
|
|
function init(callback) {
|
|
initAndGetUser(argv.user, callback);
|
|
},
|
|
function setNewPass(user, callback) {
|
|
user.setNewAuthCredentials(argv.password, function credsSet(err) {
|
|
if(err) {
|
|
process.exitCode = ExitCodes.ERROR;
|
|
callback(new Error('Failed setting password'));
|
|
} else {
|
|
callback(null);
|
|
}
|
|
});
|
|
}
|
|
],
|
|
function complete(err) {
|
|
if(err) {
|
|
console.error(err.message);
|
|
} else {
|
|
console.info('Password set');
|
|
}
|
|
}
|
|
);
|
|
} else if(argv.activate) {
|
|
setAccountStatus(argv.user, true);
|
|
} else if(argv.deactivate) {
|
|
setAccountStatus(argv.user, false);
|
|
}
|
|
}
|
|
|
|
function getAnswers(questions, cb) {
|
|
inq.prompt(questions).then( answers => {
|
|
return cb(answers);
|
|
});
|
|
}
|
|
|
|
function getDefaultConfigPath() {
|
|
return resolvePath('~/.config/enigma-bbs/config.hjson');
|
|
}
|
|
|
|
const QUESTIONS = {
|
|
Intro : [
|
|
{
|
|
name : 'createNewConfig',
|
|
message : 'Create a new configuration?',
|
|
type : 'confirm',
|
|
default : false,
|
|
},
|
|
{
|
|
name : 'configPath',
|
|
message : 'Configuration path:',
|
|
default : argv.config ? argv.config : getDefaultConfigPath(),
|
|
when : answers => answers.createNewConfig
|
|
},
|
|
],
|
|
|
|
OverwriteConfig : [
|
|
{
|
|
name : 'overwriteConfig',
|
|
message : 'Config file exists. Overwrite?',
|
|
type : 'confirm',
|
|
default : false,
|
|
}
|
|
],
|
|
|
|
Basic : [
|
|
{
|
|
name : 'boardName',
|
|
message : 'BBS name:',
|
|
default : 'New ENiGMA½ BBS',
|
|
},
|
|
],
|
|
|
|
Misc : [
|
|
{
|
|
name : 'loggingLevel',
|
|
message : 'Logging level:',
|
|
type : 'list',
|
|
choices : [ 'Error', 'Warn', 'Info', 'Debug', 'Trace' ],
|
|
default : 2,
|
|
filter : s => s.toLowerCase(),
|
|
},
|
|
{
|
|
name : 'sevenZipExe',
|
|
message : '7-Zip executable:',
|
|
type : 'list',
|
|
choices : [ '7z', '7za', 'None' ]
|
|
}
|
|
],
|
|
|
|
MessageConfAndArea : [
|
|
{
|
|
name : 'msgConfName',
|
|
message : 'First message conference:',
|
|
default : 'Local',
|
|
},
|
|
{
|
|
name : 'msgConfDesc',
|
|
message : 'Conference description:',
|
|
default : 'Local Areas',
|
|
},
|
|
{
|
|
name : 'msgAreaName',
|
|
message : 'First area in message conference:',
|
|
default : 'General',
|
|
},
|
|
{
|
|
name : 'msgAreaDesc',
|
|
message : 'Area description:',
|
|
default : 'General chit-chat',
|
|
}
|
|
]
|
|
};
|
|
|
|
function makeMsgConfAreaName(s) {
|
|
return s.toLowerCase().replace(/\s+/g, '_');
|
|
}
|
|
|
|
function askNewConfigQuestions(cb) {
|
|
|
|
const ui = new inq.ui.BottomBar();
|
|
|
|
let configPath;
|
|
let config;
|
|
|
|
async.waterfall(
|
|
[
|
|
function intro(callback) {
|
|
getAnswers(QUESTIONS.Intro, answers => {
|
|
if(!answers.createNewConfig) {
|
|
return callback('exit');
|
|
}
|
|
|
|
// adjust for ~ and the like
|
|
configPath = resolvePath(answers.configPath);
|
|
|
|
const configDir = paths.dirname(configPath);
|
|
mkdirsSync(configDir);
|
|
|
|
//
|
|
// Check if the file exists and can be written to
|
|
//
|
|
fs.access(configPath, fs.F_OK | fs.W_OK, err => {
|
|
if(err) {
|
|
if('EACCES' === err.code) {
|
|
ui.log.write(`${configPath} cannot be written to`);
|
|
callback('exit');
|
|
} else if('ENOENT' === err.code) {
|
|
callback(null, false);
|
|
}
|
|
} else {
|
|
callback(null, true); // exists + writable
|
|
}
|
|
});
|
|
});
|
|
},
|
|
function promptOverwrite(needPrompt, callback) {
|
|
if(needPrompt) {
|
|
getAnswers(QUESTIONS.OverwriteConfig, answers => {
|
|
callback(answers.overwriteConfig ? null : 'exit');
|
|
});
|
|
} else {
|
|
callback(null);
|
|
}
|
|
},
|
|
function basic(callback) {
|
|
getAnswers(QUESTIONS.Basic, answers => {
|
|
config = {
|
|
general : {
|
|
boardName : answers.boardName,
|
|
},
|
|
};
|
|
|
|
callback(null);
|
|
});
|
|
},
|
|
function msgConfAndArea(callback) {
|
|
getAnswers(QUESTIONS.MessageConfAndArea, answers => {
|
|
config.messageConferences = {};
|
|
|
|
const confName = makeMsgConfAreaName(answers.msgConfName);
|
|
const areaName = makeMsgConfAreaName(answers.msgAreaName);
|
|
|
|
config.messageConferences[confName] = {
|
|
name : answers.msgConfName,
|
|
desc : answers.msgConfDesc,
|
|
sort : 1,
|
|
default : true,
|
|
};
|
|
|
|
config.messageConferences.another_sample_conf = {
|
|
name : 'Another Sample Conference',
|
|
desc : 'Another conference example. Change me!',
|
|
sort : 2,
|
|
};
|
|
|
|
config.messageConferences[confName].areas = {};
|
|
config.messageConferences[confName].areas[areaName] = {
|
|
name : answers.msgAreaName,
|
|
desc : answers.msgAreaDesc,
|
|
sort : 1,
|
|
default : true,
|
|
};
|
|
|
|
config.messageConferences.another_sample_conf = {
|
|
areas : {
|
|
another_sample_area : {
|
|
name : 'Another Sample Area',
|
|
desc : 'Another area example. Change me!',
|
|
sort : 2
|
|
}
|
|
}
|
|
};
|
|
|
|
callback(null);
|
|
});
|
|
},
|
|
function misc(callback) {
|
|
getAnswers(QUESTIONS.Misc, answers => {
|
|
if('None' !== answers.sevenZipExe) {
|
|
config.archivers = {
|
|
zip : {
|
|
compressCmd : answers.sevenZipExe,
|
|
decompressCmd : answers.sevenZipExe,
|
|
}
|
|
};
|
|
}
|
|
|
|
config.logging = {
|
|
level : answers.loggingLevel,
|
|
};
|
|
|
|
callback(null);
|
|
});
|
|
}
|
|
],
|
|
err => {
|
|
cb(err, configPath, config);
|
|
}
|
|
);
|
|
}
|
|
|
|
function handleConfigCommand() {
|
|
if(true === argv.help) {
|
|
return printUsageAndSetExitCode('Config', ExitCodes.ERROR);
|
|
}
|
|
|
|
if(argv.new) {
|
|
askNewConfigQuestions( (err, configPath, config) => {
|
|
if(err) {
|
|
return;
|
|
}
|
|
|
|
config = hjson.stringify(config, { bracesSameLine : true, spaces : '\t' } );
|
|
|
|
try {
|
|
fs.writeFileSync(configPath, config, 'utf8');
|
|
console.info('Configuration generated');
|
|
} catch(e) {
|
|
console.error('Exception attempting to create config: ' + e.toString());
|
|
}
|
|
});
|
|
} else {
|
|
return printUsageAndSetExitCode('Config', ExitCodes.ERROR);
|
|
}
|
|
}
|
|
|
|
function fileAreaScan(areaTag) {
|
|
async.waterfall(
|
|
[
|
|
function init(callback) {
|
|
return initConfigAndDatabases(callback);
|
|
},
|
|
function getFileArea(callback) {
|
|
const fileAreaMod = require('./core/file_area.js');
|
|
|
|
const areaInfo = fileAreaMod.getFileAreaByTag(argv.scan);
|
|
if(!areaInfo) {
|
|
return callback(new Error('Invalid file area'));
|
|
}
|
|
|
|
return callback(null, fileAreaMod, areaInfo);
|
|
},
|
|
function performScan(fileAreaMod, areaInfo, callback) {
|
|
fileAreaMod.scanFileAreaForChanges(areaInfo, err => {
|
|
|
|
});
|
|
}
|
|
],
|
|
err => {
|
|
if(err) {
|
|
process.exitCode = ExitCodes.ERROR;
|
|
console.error(err.message);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
function handleFileAreaCommand() {
|
|
if(true === argv.help) {
|
|
return printUsageAndSetExitCode('FileArea', ExitCodes.ERROR);
|
|
}
|
|
|
|
if(argv.scan) {
|
|
return fileAreaScan(argv.scan);
|
|
}
|
|
}
|
|
|
|
function main() {
|
|
|
|
process.exitCode = ExitCodes.SUCCESS;
|
|
|
|
if(true === argv.version) {
|
|
return console.info(require('./package.json').version);
|
|
}
|
|
|
|
if(0 === argv._.length ||
|
|
'help' === argv._[0])
|
|
{
|
|
printUsageAndSetExitCode('General', ExitCodes.SUCCESS);
|
|
}
|
|
|
|
switch(argv._[0]) {
|
|
case 'user' :
|
|
handleUserCommand();
|
|
break;
|
|
|
|
case 'config' :
|
|
handleConfigCommand();
|
|
break;
|
|
|
|
case 'file-area' :
|
|
handleFileAreaCommand();
|
|
break;
|
|
|
|
default:
|
|
printUsageAndSetExitCode('', ExitCodes.BAD_COMMAND);
|
|
}
|
|
}
|
|
|
|
main(); |