SearchEngine.indexing = function (pathToEpubs, callback) {
if (fs.isEmptySync(pathToEpubs)) {
return callback(new Error('Can`t index empty folder: ' + pathToEpubs));
}
console.log("******************************************************");
console.log("Step 1");
console.log("start normalize epub content");
path.normalize(pathToEpubs);
preparer.normalize(pathToEpubs, function (dataSet) {
console.log("ready normalize epub content");
console.log("******************************************************");
console.log("Step 2");
console.log("start indexing");
SearchEngine.add(dataSet, function (err) {
//console.log(dataSet);
if (callback) {
if (err)
callback(err);
else
callback('all is indexed');
}
});
//callback('all is indexed');
});
};
.action(function(templateName) {
var destPath = process.cwd();
var templates = _.filter(requireTemplates(), {type: 'app'});
templateName = templateName || 'basic';
var template = _.find(templates, {name: templateName});
if (!template) {
console.error('Error:'.red + ' no template named ' + templateName);
console.error('Available templates:');
console.error(getTemplatesInfo(templates));
return;
}
if (!extfs.isEmptySync(destPath)) {
console.error('Error:'.red + ' Current directory is not empty.');
console.error('Error:'.red + ' Please go to an empty dir and run again.');
return;
}
deployTemplate(template, destPath, function(err, res) {
if (err) {
return console.error('Error: '.red + err);
}
console.log(getSuccessInfo(template.name));
});
});
fs.readdirSync(dbPath).forEach(it => {
const dirPath = path.resolve(dbPath, it);
const dirStat = fs.statSync(dirPath);
if (dirStat.isDirectory()) {
if (fs.isEmptySync(dirPath)) {
var now = new Date().getTime();
var endTime = new Date(dirStat.ctime).getTime() + 3600; // in ms (3600000 = 1 hour)
if (now > endTime) {
rimraf(dirPath, function () {
console.log('Cleanup: removed empty directory: ' + dirPath);
});
}
} else {
fs.readdirSync(dirPath).forEach(it => {
const filePath = path.resolve(dirPath, it);
const fileStat = fs.statSync(filePath);
var now = new Date().getTime();
var endTime = new Date(fileStat.ctime).getTime() + 8640000000; // in ms (8640000000 = 100 days)
if (now > endTime) {
rimraf(filePath, function () {
console.log('Cleanup: removed old entry (100 days): ' + filePath);
});
}
});
}
}
});
function deleteFile(file, oldRoot, newRoot, newExt) {
var oldPath = path.relative(oldRoot, file);
var newFileName = path.basename(oldPath, path.extname(oldPath)) + newExt;
var newPath = path.resolve(newRoot, path.join(path.dirname(oldPath), newFileName));
del.sync(newPath);
var newDir = path.dirname(newPath);
if (fs.isEmptySync(newDir)) del.sync(newDir);
}
createCordova: function () {
var path = fs.isEmptySync('./') ? './' : this.name.toLowerCase();
var self = this;
var done = this.async();
this.spawnCommand('cordova', ['create', path, this.identifier, this.name]).on('exit', function (status) {
if (status !== 0) {
self.log('Something went wrong');
}
else {
done();
}
});
},
var checkProjectFolder = function (src) {
// === Check if has an input path
if (!src) {
util.log(chalk.red('You need to specify a path!'));
process.exit();
}
// === Check if is a file
if (fs.statSync(src).isFile()) {
util.log(chalk.red("You need to specifie a folder not a file"));
process.exit();
}
// === Check if is an empty folder
else if (dir.isEmptySync(src)) {
util.log(chalk.red("You're trying to use a empty folder."));
process.exit();
}
};
Plugins.prototype.load = function (complete) {
var self = this;
//Nothing to do...
if (!fs.existsSync(pluginsDir) || extfs.isEmptySync(pluginsDir)) {
complete(new Error("No plugins to load"));
}
self.loadedPlugs = [];
this.plugins = self.observs.typesConfiguration;
if(self.plugins.get('amtechM2mBridge').instances.count() > 1){
complete(new Error(util.format("There are more than one amtechM2mBridge instance configure for follower %s.", self.bc.dap.userId)));
}
if (!self.plugins.get('amtechM2mBridge') ||
!self.plugins.get('amtechM2mBridge').instances ) {
complete(new Error("amtechM2mBridge has not instance defined by autodiscovering or server side for follower " + self.bc.dap.userId));
}
if (!self.plugins.get('amtechM2mBridge').instances.get(self.plugins.get('amtechM2mBridge').instances.keys()[0]).config ) {
complete(new Error(util.format("amtechM2mBridge %s has not configuration.", self.plugins.get('amtechM2mBridge').instances.keys()[0])));
}
self.bridgeInstance = self.plugins.get('amtechM2mBridge').instances.get(self.plugins.get('amtechM2mBridge').instances.keys()[0]);
async.each(this.plugins.values(), Plugins.prototype.pluged.bind(this),
function (err) {
if (err) {
complete(err);
} else {
self.connectWS(function (error) {
if (error) {
complete(error);
} else {
self.loadedPlugs.push(util.format("Loaded: %d plugins", self.getInstances().length));
dapReconnect.plugins = self;
self.sendBridgeStarted();
complete(null, self.loadedPlugs);
}
});
}
});
};
function addPackage (pack, rest, force) {
var filesPath = _path.normalize(rode.getCorePath() + 'bin/files/new-package/');
var filesViewPath = _path.normalize(rode.getCorePath() + 'bin/files/views/');
var destPath = _path.normalize(rode.getConfig().srcDir + '/' + pack);
var viewPath = _path.normalize(rode.getConfig().views.dir + '/' + pack);
// Check if path destPath not exists
if (!force) {
if (!fs.isEmptySync(destPath)) {
throw new Error('Path not empty');
}
}
var templates = {
controller: fs.readFileSync(filesPath + 'Controller.js').toString(),
model: fs.readFileSync(filesPath + 'Model.js').toString(),
routes: fs.readFileSync(filesPath + 'routes.js').toString(),
tests: {
controller: fs.readFileSync(filesPath + 'Tests/ControllerTest.js').toString(),
model: fs.readFileSync(filesPath + 'Tests/ModelTest.js').toString()
}
};
var renderedTemplates = {
controller: renderTemplate(pack, templates.controller),
model: renderTemplate(pack, templates.model),
routes: renderTemplate(pack, templates.routes, rest),
tests: {
controller: renderTemplate(pack, templates.tests.controller),
model: renderTemplate(pack, templates.tests.model)
}
};
if (rest) {
templates.restController = fs.readFileSync(filesPath + 'RestController.js').toString();
templates.tests.restController = fs.readFileSync(filesPath + 'Tests/RestControllerTest.js').toString();
renderedTemplates.restController = renderTemplate(pack, templates.restController);
renderedTemplates.tests.restController = renderTemplate(pack, templates.tests.restController);
}
// Create Controllers
utils.mkdir(destPath + '/Controller', function () {
utils.write(destPath + '/Controller/MainController.js', renderedTemplates.controller);
utils.write(destPath + '/routes.js', renderedTemplates.routes);
if (rest) {
utils.write(destPath + '/Controller/RestController.js', renderedTemplates.restController);
}
});
// Create Models
utils.mkdir(destPath + '/Model', function () {
utils.write(destPath + '/Model/' + pack + '.js', renderedTemplates.model);
});
// Create Views
utils.writeViews(viewPath, rode.getConfig().views.engine, {
path: '../',
pack: pack
});
// Create Tests
utils.mkdir(destPath + '/Tests/Controller', function () {
utils.write(destPath + '/Tests/Controller/MainControllerTest.js', renderedTemplates.tests.controller);
if (rest) {
utils.write(destPath + '/Tests/Controller/RestControllerTest.js', renderedTemplates.tests.restController);
}
});
utils.mkdir(destPath + '/Tests/Model', function () {
utils.write(destPath + '/Tests/Model/' + pack + 'Test.js', renderedTemplates.tests.model);
});
}