enigma-bbs/core/oputil/oputil_file_base.js

1050 lines
39 KiB
JavaScript

/* jslint node: true */
/* eslint-disable no-console */
'use strict';
const printUsageAndSetExitCode = require('./oputil_common.js').printUsageAndSetExitCode;
const ExitCodes = require('./oputil_common.js').ExitCodes;
const argv = require('./oputil_common.js').argv;
const initConfigAndDatabases = require('./oputil_common.js').initConfigAndDatabases;
const getHelpFor = require('./oputil_help.js').getHelpFor;
const {
getAreaAndStorage,
looksLikePattern,
getConfigPath,
getAnswers,
writeConfig
} = require('./oputil_common.js');
const Errors = require('../enig_error.js').Errors;
const async = require('async');
const fs = require('graceful-fs');
const paths = require('path');
const _ = require('lodash');
const moment = require('moment');
const inq = require('inquirer');
const glob = require('glob');
const sanatizeFilename = require('sanitize-filename');
const hjson = require('hjson');
const { mkdirs } = require('fs-extra');
exports.handleFileBaseCommand = handleFileBaseCommand;
/*
:TODO:
Global options:
--yes: assume yes
--no-prompt: try to avoid user input
Prompt for import and description before scan
* Only after finding duplicate-by-path
* Default to filename -> desc if auto import
*/
let fileArea; // required during init
function finalizeEntryAndPersist(isUpdate, fileEntry, descHandler, cb) {
async.series(
[
function getDescFromHandlerIfNeeded(callback) {
if((fileEntry.desc && fileEntry.descSrc != 'fileName' && fileEntry.desc.length > 0 ) && !argv['desc-file']) {
return callback(null); // we have a desc already and are NOT overriding with desc file
}
if(!descHandler) {
return callback(null); // not much we can do!
}
const desc = descHandler.getDescription(fileEntry.fileName);
if(desc) {
fileEntry.desc = desc;
}
return callback(null);
},
function getDescFromUserIfNeeded(callback) {
if(fileEntry.desc && fileEntry.desc.length > 0 ) {
return callback(null);
}
const getDescFromFileName = require('../../core/file_base_area.js').getDescFromFileName;
const descFromFile = getDescFromFileName(fileEntry.fileName);
if(false === argv.prompt) {
fileEntry.desc = descFromFile;
return callback(null);
}
const questions = [
{
name : 'desc',
message : `Description for ${fileEntry.fileName}:`,
type : 'input',
default : descFromFile,
}
];
inq.prompt(questions).then( answers => {
fileEntry.desc = answers.desc;
return callback(null);
});
},
function persist(callback) {
fileEntry.persist(isUpdate, err => {
return callback(err);
});
}
],
err => {
return cb(err);
}
);
}
const SCAN_EXCLUDE_FILENAMES = [
'DESCRIPT.ION',
'FILES.BBS',
'ALLFILES.TXT',
];
function loadDescHandler(path, cb) {
const handlerClassFromFileName = {
'descript.ion' : require('../../core/descript_ion_file.js'),
'files.bbs' : require('../../core/files_bbs_file.js'),
}[paths.basename(path).toLowerCase()];
if(!handlerClassFromFileName) {
return cb(Errors.DoesNotExist(`No handlers registered for ${paths.basename(path)}`));
}
handlerClassFromFileName.createFromFile(path, (err, descHandler) => {
return cb(err, descHandler);
});
}
//
// Try to find a suitable description handler by
// checking for common filenames.
//
function findSuitableDescHandler(basePath, cb) {
const commonFiles = [ 'FILES.BBS', 'DESCRIPT.ION' ];
async.eachSeries(commonFiles, (fileName, nextFileName) => {
loadDescHandler(paths.join(basePath, fileName), (err, handler) => {
if(!err && handler) {
return cb(null, handler);
}
return nextFileName(null);
});
},
() => {
return cb(Errors.DoesNotExist('No suitable description handler available'));
});
}
function scanFileAreaForChanges(areaInfo, options, cb) {
const storageLocations = fileArea.getAreaStorageLocations(areaInfo).filter(sl => {
return options.areaAndStorageInfo.find(asi => {
return !asi.storageTag || sl.storageTag === asi.storageTag;
});
});
function updateTags(fe) {
if(Array.isArray(options.tags)) {
fe.hashTags = new Set(options.tags);
}
}
const FileEntry = require('../file_entry.js');
const readDir = options.glob ?
(dir, next) => {
return glob(options.glob, { cwd : dir, nodir : true }, next);
} :
(dir, next) => {
return fs.readdir(dir, next);
};
async.eachSeries(storageLocations, (storageLoc, nextLocation) => {
async.waterfall(
[
function initDescFile(callback) {
if(options.descFileHandler) {
return callback(null, options.descFileHandler); // we're going to use the global handler
}
findSuitableDescHandler(storageLoc.dir, (err, descHandler) => {
return callback(null, descHandler);
});
},
function scanPhysFiles(descHandler, callback) {
const physDir = storageLoc.dir;
readDir(physDir, (err, files) => {
if(err) {
return callback(err);
}
async.eachSeries(files, (fileName, nextFile) => {
const fullPath = paths.join(physDir, fileName);
if(SCAN_EXCLUDE_FILENAMES.includes(fileName.toUpperCase())) {
console.info(`Excluding ${fullPath}`);
return nextFile(null);
}
fs.stat(fullPath, (err, stats) => {
if(err) {
// :TODO: Log me!
return nextFile(null); // always try next file
}
if(!stats.isFile()) {
return nextFile(null);
}
process.stdout.write(`Scanning ${fullPath}... `);
async.series(
[
function quickCheck(next) {
if(options['full']) {
return next(null);
}
FileEntry.quickCheckExistsByPath(fullPath, (err, exists) => {
if(exists) {
console.info('Dupe');
return nextFile(null);
}
return next(null);
});
},
function fullScan() {
fileArea.scanFile(
fullPath,
{
areaTag : areaInfo.areaTag,
storageTag : storageLoc.storageTag
},
(stepInfo, next) => {
if(argv.verbose) {
if(stepInfo.error) {
console.error(` error: ${stepInfo.error}`);
} else {
console.info(` processing: ${stepInfo.step}`);
}
}
return next(null);
},
(err, fileEntry, dupeEntries) => {
if(err) {
console.info(`Error: ${err.message}`);
return nextFile(null); // try next anyway
}
//
// We'll update the entry if the following conditions are met:
// * We have a single duplicate, and:
// * --update was passed or the existing entry's desc,
// longDesc, or est_release_year meta are blank/empty
//
if(argv.update && 1 === dupeEntries.length) {
const FileEntry = require('../../core/file_entry.js');
const existingEntry = new FileEntry();
return existingEntry.load(dupeEntries[0].fileId, err => {
if(err) {
console.info('Dupe (cannot update)');
return nextFile(null);
}
//
// Update only if tags or desc changed
//
const optTags = Array.isArray(options.tags) ? new Set(options.tags) : existingEntry.hashTags;
const tagsEq = _.isEqual(optTags, existingEntry.hashTags);
let descSauceCompare;
if(existingEntry.meta.desc_sauce) {
descSauceCompare = JSON.stringify(existingEntry.meta.desc_sauce);
}
if( tagsEq &&
fileEntry.desc === existingEntry.desc &&
fileEntry.descLong === existingEntry.descLong &&
fileEntry.meta.est_release_year === existingEntry.meta.est_release_year &&
fileEntry.meta.desc_sauce === descSauceCompare
)
{
console.info('Dupe');
return nextFile(null);
}
console.info('Dupe (updating)');
// don't allow overwrite of values if new version is blank
existingEntry.desc = fileEntry.desc || existingEntry.desc;
existingEntry.descLong = fileEntry.descLong || existingEntry.descLong;
if(fileEntry.meta.est_release_year) {
existingEntry.meta.est_release_year = fileEntry.meta.est_release_year;
}
if(fileEntry.meta.desc_sauce) {
existingEntry.meta.desc_sauce = fileEntry.meta.desc_sauce;
}
updateTags(existingEntry);
finalizeEntryAndPersist(true, existingEntry, descHandler, err => {
return nextFile(err);
});
});
} else if(dupeEntries.length > 0) {
console.info('Dupe');
return nextFile(null);
}
console.info('Done!');
updateTags(fileEntry);
finalizeEntryAndPersist(false, fileEntry, descHandler, err => {
return nextFile(err);
});
}
);
}
]
);
});
}, err => {
return callback(err);
});
});
},
function scanDbEntries(callback) {
// :TODO: Look @ db entries for area that were *not* processed above
return callback(null);
}
],
err => {
return nextLocation(err);
}
);
},
err => {
return cb(err);
});
}
function dumpAreaInfo(areaInfo, areaAndStorageInfo, cb) {
console.info(`areaTag: ${areaInfo.areaTag}`);
console.info(`name: ${areaInfo.name}`);
console.info(`desc: ${areaInfo.desc}`);
areaInfo.storage.forEach(si => {
console.info(`storageTag: ${si.storageTag} => ${si.dir}`);
});
console.info('');
return cb(null);
}
function getFileEntries(pattern, cb) {
// spec: FILENAME_WC|FILE_ID|SHA|PARTIAL_SHA
const FileEntry = require('../../core/file_entry.js');
async.waterfall(
[
function tryByFileId(callback) {
const fileId = parseInt(pattern);
if(!/^[0-9]+$/.test(pattern) || isNaN(fileId)) {
return callback(null, null); // try SHA
}
const fileEntry = new FileEntry();
fileEntry.load(fileId, err => {
return callback(null, err ? null : [ fileEntry ] );
});
},
function tryByShaOrPartialSha(entries, callback) {
if(entries) {
return callback(null, entries); // already got it by FILE_ID
}
FileEntry.findBySha(pattern, (err, fileEntry) => {
return callback(null, fileEntry ? [ fileEntry ] : null );
});
},
function tryByFileNameWildcard(entries, callback) {
if(entries) {
return callback(null, entries); // already got by FILE_ID|SHA
}
return FileEntry.findByFileNameWildcard(pattern, callback);
}
],
(err, entries) => {
return cb(err, entries);
}
);
}
function dumpFileInfo(shaOrFileId, cb) {
async.waterfall(
[
function getEntry(callback) {
getFileEntries(shaOrFileId, (err, entries) => {
if(err) {
return callback(err);
}
return callback(null, entries[0]);
});
},
function dumpInfo(fileEntry, callback) {
const fullPath = paths.join(fileArea.getAreaStorageDirectoryByTag(fileEntry.storageTag), fileEntry.fileName);
console.info(`file_id: ${fileEntry.fileId}`);
console.info(`sha_256: ${fileEntry.fileSha256}`);
console.info(`area_tag: ${fileEntry.areaTag}`);
console.info(`storage_tag: ${fileEntry.storageTag}`);
console.info(`path: ${fullPath}`);
console.info(`hashTags: ${Array.from(fileEntry.hashTags).join(', ')}`);
console.info(`uploaded: ${moment(fileEntry.uploadTimestamp).format()}`);
_.each(fileEntry.meta, (metaValue, metaName) => {
console.info(`${metaName}: ${metaValue}`);
});
if(argv['show-desc']) {
console.info(`${fileEntry.desc}`);
}
console.info('');
return callback(null);
}
],
err => {
return cb(err);
}
);
}
function displayFileOrAreaInfo() {
// AREA_TAG[@STORAGE_TAG]
// SHA256|PARTIAL|FILE_ID|FILENAME_WILDCARD
// if sha: dump file info
// if area/storage dump area(s) +
async.series(
[
function init(callback) {
return initConfigAndDatabases(callback);
},
function dumpInfo(callback) {
const sysConfig = require('../../core/config.js').get();
let suppliedAreas = argv._.slice(2);
if(!suppliedAreas || 0 === suppliedAreas.length) {
suppliedAreas = _.map(sysConfig.fileBase.areas, (areaInfo, areaTag) => areaTag);
}
const areaAndStorageInfo = getAreaAndStorage(suppliedAreas);
fileArea = require('../../core/file_base_area.js');
async.eachSeries(areaAndStorageInfo, (areaAndStorage, nextArea) => {
const areaInfo = fileArea.getFileAreaByTag(areaAndStorage.areaTag);
if(areaInfo) {
return dumpAreaInfo(areaInfo, areaAndStorageInfo, nextArea);
} else {
return dumpFileInfo(areaAndStorage.areaTag, nextArea);
}
},
err => {
return callback(err);
});
}
],
err => {
if(err) {
process.exitCode = ExitCodes.ERROR;
console.error(err.message);
}
}
);
}
function scanFileAreas() {
const options = {};
const tags = argv.tags;
if(tags) {
options.tags = tags.split(',');
}
options.descFile = argv['desc-file']; // --desc-file or --desc-file PATH
options['full'] = argv.full;
options.areaAndStorageInfo = getAreaAndStorage(argv._.slice(2));
const last = argv._[argv._.length - 1];
if(options.areaAndStorageInfo.length > 1 && looksLikePattern(last)) {
options.glob = last;
options.areaAndStorageInfo.length -= 1;
}
async.series(
[
function init(callback) {
return initConfigAndDatabases(callback);
},
function initMime(callback) {
return require('../../core/mime_util.js').startup(callback);
},
function initGlobalDescHandler(callback) {
//
// If options.descFile is a String, it represents a FILE|PATH. We'll init
// the description handler now. Else, we'll attempt to look for a description
// file in each storage location.
//
if(!_.isString(options.descFile)) {
return callback(null);
}
loadDescHandler(options.descFile, (err, descHandler) => {
options.descFileHandler = descHandler;
return callback(null);
});
},
function scanAreas(callback) {
fileArea = require('../../core/file_base_area');
// Further expand any wildcards
let areaAndStorageInfoExpanded = [];
options.areaAndStorageInfo.forEach(info => {
if (info.areaTag.indexOf('*') > -1) {
const areas = fileArea.getFileAreasByTagWildcardRule(info.areaTag);
areas.forEach(area => {
areaAndStorageInfoExpanded.push(Object.assign({}, info, {
areaTag : area.areaTag,
}));
});
} else {
areaAndStorageInfoExpanded.push(info);
}
});
options.areaAndStorageInfo = areaAndStorageInfoExpanded;
async.eachSeries(options.areaAndStorageInfo, (areaAndStorage, nextAreaTag) => {
const areaInfo = fileArea.getFileAreaByTag(areaAndStorage.areaTag);
if(!areaInfo) {
return nextAreaTag(new Error(`Invalid file base area tag: ${areaAndStorage.areaTag}`));
}
console.info(`Processing area "${areaInfo.name}":`);
scanFileAreaForChanges(areaInfo, options, err => {
return callback(err);
});
}, err => {
return callback(err);
});
}
],
err => {
if(err) {
process.exitCode = ExitCodes.ERROR;
console.error(err.message);
}
}
);
}
function expandFileTargets(targets, cb) {
let entries = [];
// Each entry may be PATH|FILE_ID|SHA|AREA_TAG[@STORAGE_TAG]
const FileEntry = require('../../core/file_entry.js');
async.eachSeries(targets, (areaAndStorage, next) => {
const areaInfo = fileArea.getFileAreaByTag(areaAndStorage.areaTag);
if(areaInfo) {
// AREA_TAG[@STORAGE_TAG] - all files in area@tag
const findFilter = {
areaTag : areaAndStorage.areaTag,
};
if(areaAndStorage.storageTag) {
findFilter.storageTag = areaAndStorage.storageTag;
}
FileEntry.findFiles(findFilter, (err, fileIds) => {
if(err) {
return next(err);
}
async.each(fileIds, (fileId, nextFileId) => {
const fileEntry = new FileEntry();
fileEntry.load(fileId, err => {
if(!err) {
entries.push(fileEntry);
}
return nextFileId(err);
});
},
err => {
return next(err);
});
});
} else {
// FILENAME_WC|FILE_ID|SHA|PARTIAL_SHA
// :TODO: FULL_PATH -> entries
getFileEntries(areaAndStorage.pattern, (err, fileEntries) => {
if(err) {
return next(err);
}
entries = entries.concat(fileEntries);
return next(null);
});
}
},
err => {
return cb(err, entries);
});
}
function moveFiles() {
//
// oputil fb move SRC [SRC2 ...] DST
//
// SRC: FILENAME_WC|FILE_ID|SHA|AREA_TAG[@STORAGE_TAG]
// DST: AREA_TAG[@STORAGE_TAG]
//
if(argv._.length < 4) {
return printUsageAndSetExitCode(getHelpFor('FileBase'), ExitCodes.ERROR);
}
const moveArgs = argv._.slice(2);
const src = getAreaAndStorage(moveArgs.slice(0, -1));
const dst = getAreaAndStorage(moveArgs.slice(-1))[0];
let FileEntry;
async.waterfall(
[
function init(callback) {
return initConfigAndDatabases( err => {
if(!err) {
fileArea = require('../../core/file_base_area.js');
}
return callback(err);
});
},
function validateAndExpandSourceAndDest(callback) {
const areaInfo = fileArea.getFileAreaByTag(dst.areaTag);
if(areaInfo) {
dst.areaInfo = areaInfo;
} else {
return callback(Errors.DoesNotExist('Invalid or unknown destination area'));
}
FileEntry = require('../../core/file_entry.js');
expandFileTargets(src, (err, srcEntries) => {
return callback(err, srcEntries);
});
},
function moveEntries(srcEntries, callback) {
if(!dst.storageTag) {
dst.storageTag = dst.areaInfo.storageTags[0];
}
const destDir = FileEntry.getAreaStorageDirectoryByTag(dst.storageTag);
async.eachSeries(srcEntries, (entry, nextEntry) => {
const srcPath = entry.filePath;
const dstPath = paths.join(destDir, entry.fileName);
process.stdout.write(`Moving ${srcPath} => ${dstPath}... `);
FileEntry.moveEntry(entry, dst.areaTag, dst.storageTag, err => {
if(err) {
console.info(`Failed: ${err.message}`);
} else {
console.info('Done');
}
return nextEntry(null); // always try next
});
},
err => {
return callback(err);
});
}
],
err => {
if(err) {
process.exitCode = ExitCodes.ERROR;
console.error(err.message);
}
}
);
}
function removeFiles() {
//
// oputil fb rm|remove|del|delete SRC [SRC2 ...]
//
// SRC: FILENAME_WC|FILE_ID|SHA|AREA_TAG[@STORAGE_TAG]
//
// AREA_TAG[@STORAGE_TAG] remove all entries matching
// supplied area/storage tags
//
// --phys-file removes backing physical file(s)
//
if(argv._.length < 3) {
return printUsageAndSetExitCode(getHelpFor('FileBase'), ExitCodes.ERROR);
}
const removePhysFile = argv['phys-file'];
const src = getAreaAndStorage(argv._.slice(2));
async.waterfall(
[
function init(callback) {
return initConfigAndDatabases( err => {
if(!err) {
fileArea = require('../../core/file_base_area.js');
}
return callback(err);
});
},
function expandSources(callback) {
expandFileTargets(src, (err, srcEntries) => {
return callback(err, srcEntries);
});
},
function removeEntries(srcEntries, callback) {
const FileEntry = require('../../core/file_entry.js');
const extraOutput = removePhysFile ? ' (including physical file)' : '';
async.eachSeries(srcEntries, (entry, nextEntry) => {
process.stdout.write(`Removing ${entry.filePath}${extraOutput}... `);
FileEntry.removeEntry(entry, { removePhysFile }, err => {
if(err) {
console.info(`Failed: ${err.message}`);
} else {
console.info('Done');
}
return nextEntry(err);
});
}, err => {
return callback(err);
});
}
],
err => {
if(err) {
process.exitCode = ExitCodes.ERROR;
console.error(err.message);
}
}
);
}
function getFileBaseImportType(path) {
if(argv.type) {
return argv.type.toLowerCase();
}
return paths.extname(path).substr(1).toLowerCase(); // zxx, ...
}
function importFileAreas() {
//
// FILEGATE.ZXX "RAID" format currently the only supported format.
//
// See http://www.filegate.net/info/filegate.zxx
// ...same format as FILEBONE.NA:
// http://wiki.mysticbbs.com/doku.php?id=mutil_import_filebone_na
//
const importPath = argv._[argv._.length - 1];
if(argv._.length < 3 || !importPath || 0 === importPath.length) {
return printUsageAndSetExitCode(getHelpFor('FileBase'), ExitCodes.ERROR);
}
const importType = getFileBaseImportType(importPath);
if(!['zxx', 'na'].includes(importType)) {
return console.error(`"${importType}" is not a recognized import file type`);
}
const createDirs = argv['create-dirs'];
// :TODO: --base-dir (override config base/relative dir; use full paths)
async.waterfall(
[
(callback) => {
fs.readFile(importPath, 'utf8', (err, importData) => {
if(err) {
return callback(err);
}
const importInfo = {
storageTags : {},
areas : {},
count : 0,
};
const re = /Area\s+([^\s]+)\s+[0-9]\s+(?:!|\*&)\s+([^\r\n]+)/gm;
let m;
while((m = re.exec(importData))) {
const dir = m[1].trim();
const name = m[2].trim();
const safeName = sanatizeFilename(name);
const stPrefix = _.snakeCase(sanatizeFilename(safeName));
const storageTag = `${stPrefix}__${_.snakeCase(sanatizeFilename(dir))}`;
const areaTag = _.snakeCase(safeName);
if(!dir || !name || !storageTag || !areaTag) {
console.info(`Skipping entry: ${m[0]}`);
continue;
}
importInfo.storageTags[storageTag] = dir;
importInfo.areas[areaTag] = {
name : name,
desc : name,
storageTags : [ storageTag ],
};
++importInfo.count;
}
if(0 === importInfo.count) {
return callback(new Error('Nothing to import'));
}
return callback(null, importInfo);
});
},
(importInfo, callback) => {
return initConfigAndDatabases(err => {
return callback(err, importInfo);
});
},
(importInfo, callback) => {
console.info(`Read to import the following ${importInfo.count} areas:`);
console.info('');
_.each(importInfo.areas, (area, areaTag) => {
console.info(`${area.name} (${areaTag}):`);
const dir = importInfo.storageTags[area.storageTags[0]];
console.info(` storage: ${area.storageTags[0]} => ${dir}`);
});
getAnswers([
{
name : 'proceed',
message : 'Proceed?',
type : 'confirm',
}
],
answers => {
if(answers.proceed) {
return callback(null, importInfo);
}
return callback(Errors.General('User canceled'));
});
},
(importInfo, callback) => {
fs.readFile(getConfigPath(), 'utf8', (err, configData) => {
if(err) {
return callback(err);
}
let config;
try {
config = hjson.rt.parse(configData);
} catch(e) {
return callback(e);
}
return callback(null, importInfo, config);
});
},
(importInfo, config, callback) => {
const newStorageTagDirs = [];
_.each(importInfo.areas, (area, areaTag) => {
const existingArea = _.get(config, [ 'fileBase', 'areas', areaTag ]);
if(existingArea) {
return console.info(`Skipping ${area.name}. Area tag "${areaTag}" already exists.`);
}
const storageTag = area.storageTags[0];
const existingStorageTag = _.get(config, [ 'fileBase', 'storageTags', storageTag ]);
if(existingStorageTag) {
return console.info(`Skipping ${area.name} (${areaTag}). Storage tag "${storageTag}" already exists`);
}
const dir = importInfo.storageTags[storageTag];
newStorageTagDirs.push(dir);
config.fileBase.storageTags[storageTag] = dir;
config.fileBase.areas[areaTag] = area;
});
return callback(null, newStorageTagDirs, config);
},
(newStorageTagDirs, config, callback) => {
if(!createDirs) {
return callback(null, config);
}
//
// Create all directories
//
const prefixDir = config.fileBase.areaStoragePrefix;
async.eachSeries(newStorageTagDirs, (dir, nextDir) => {
const isAbs = paths.isAbsolute(dir);
if(!isAbs) {
dir = paths.join(prefixDir, dir);
}
mkdirs(dir, err => {
if(!err) {
console.log(`Created ${dir}`);
}
return nextDir(err);
});
},
err => {
return callback(err, config);
});
},
(config, callback) => {
const written = writeConfig(config, getConfigPath());
return callback(written ? null : new Error('Failed to write config!'));
}
],
err => {
if(err) {
return console.error(err.reason ? err.reason : err.message);
}
console.info('Import complete.');
console.info(`You may wish to validate changes made to ${getConfigPath()}`);
}
);
}
function setFileDescription() {
//
// ./oputil.js fb set-desc CRITERIA # will prompt
// ./oputil.js fb set-desc CRITERIA "The new description"
//
let fileCriteria;
let desc;
if(argv._.length > 3) {
fileCriteria = argv._[argv._.length - 2];
desc = argv._[argv._.length - 1];
} else {
fileCriteria = argv._[argv._.length - 1];
}
async.waterfall(
[
(callback) => {
return initConfigAndDatabases(callback);
},
(callback) => {
getFileEntries(fileCriteria, (err, entries) => {
if(err) {
return callback(err);
}
if(entries.length > 1) {
return callback(Errors.General('Criteria not specific enough.'));
}
return callback(null, entries[0]);
});
},
(fileEntry, callback) => {
if(desc) {
return callback(null, fileEntry, desc);
}
getAnswers([
{
name : 'userDesc',
message : 'Description:',
type : 'editor',
}
],
answers => {
if(!answers.userDesc) {
return callback(Errors.General('User canceled'));
}
return callback(null, fileEntry, answers.userDesc);
});
},
(fileEntry, newDesc, callback) => {
fileEntry.desc = newDesc;
fileEntry.persist(true, err => { // true=isUpdate
return callback(err);
});
}
],
err => {
if(err) {
process.exitCode = ExitCodes.ERROR;
console.error(err.message);
} else {
console.info('Description updated.');
}
}
);
}
function handleFileBaseCommand() {
function errUsage() {
return printUsageAndSetExitCode(
getHelpFor('FileBase') + getHelpFor('FileOpsInfo'),
ExitCodes.ERROR
);
}
if(true === argv.help) {
return errUsage();
}
const action = argv._[1];
return ({
info : displayFileOrAreaInfo,
scan : scanFileAreas,
mv : moveFiles,
move : moveFiles,
rm : removeFiles,
remove : removeFiles,
del : removeFiles,
delete : removeFiles,
'import-areas' : importFileAreas,
desc : setFileDescription,
description : setFileDescription,
}[action] || errUsage)();
}