yoanm / alfred-personal-assistant

server/plugin.js

var fs      = require('fs-extra');

var request = require('request');

var express = require('express');

var extend  = require('extend');


// ------------------------------------------

//  CONSTRUCTOR

// ------------------------------------------


var init = function(){

  info('Starting PluginManager ...');

  

  // Refresh local plugins

  refresh();

  

  return PluginManager;

}


// ------------------------------------------

//  HELPER: REQUIRE 

// ------------------------------------------


/**

 * Removes a module from the cache

 */

require.uncache = function (moduleName) {

  // Run over the cache looking for the files

  // loaded by the specified module name

  require.searchCache(moduleName, function (mod) {

    delete require.cache[mod.id];

  });

};


/**

 * Runs over the cache to search for all the cached files

 */

require.searchCache = function (moduleName, callback) {

  // Resolve the module identified by the specified name

  var mod = require.resolve(moduleName);


  // Check if the module has been resolved and found within

  // the cache

  if (mod && ((mod = require.cache[mod]) !== undefined)) {

    // Recursively go over the results

    (function run(mod) {

      // Go over each of the module's children and

      // run over it

      mod.children.forEach(function (child) {

          run(child);

      });


      // Call the specified callback providing the

      // found module

      callback(mod);

    })(mod);

  }

};


// ------------------------------------------

//  CLASS: PLUGIN

// ------------------------------------------


var TYPE_MODULES  = 'modules';

var TYPE_PHANTOMS = 'phantoms';

var TYPE_CRON     = 'cron';


function Plugin(options) {

  extend(false, this, options);

  

  // Link configuration

  this.config   = Config[TYPE_MODULES][this.name];

  this.phantoms = Config[TYPE_PHANTOMS][this.name];

  this.cron     = Config[TYPE_CRON][this.name];

  

  // Check has {plugin}.js

  var script = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/'+this.name+'.js';

  if (fs.existsSync(script)){ 

    this.script = script;

  }

  

  // Check has custom portlet.ejs

  var template = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/portlet.ejs';

  if (fs.existsSync(template)){

    this.template = template;

  } else {

    this.template = 'portlet.html';

  }

  

  // Check has index.ejs

  var index = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/index.ejs';

  if (fs.existsSync(index)){

    this.index = index;

  }

}


Plugin.prototype.isDisabled = function(){

  if (!this.script) return true;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

  return this.config.disabled;

}



Plugin.prototype.getLocale = function(locale){

  var path = SARAH.ConfigManager.PLUGIN+'/'+this.name+'/locales/'+locale+'.js';

  if (!fs.existsSync(path)){ info('No locals',path); return; }

  try { 

    var json = fs.readFileSync(path,'utf-8');

    info('Loading locales %s', path); 

    if (json) return JSON.parse(json); 

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

  } 

  catch(ex){ warn("Can't parse %s locales in %s", this.name, locale); }

  

  return false;

}


Plugin.prototype.getInstance = function(uncache){

  try {

    // Dispose

    if (Config.debug || uncache){ 

      if (this._script && this._script.dispose){ this._script.dispose(SARAH); }

      require.uncache(this.script); 

    }

    

    // Require

    this._script = require(this.script);

    

    // Initialise

    if (!this._script.initialized){

      this._script.initialized = true;

      if (this._script.init){ this._script.init(SARAH); }

    }

    

    // Last Modified

    var modified = fs.statSync(this.script).mtime.getTime();

    if (!this._script.lastModified){

      this._script.lastModified = modified;

    }

    

    // Reload if new version

    if (this._script.lastModified < modified){

      info('Reloading: ', this.name);

      return this.getInstance(true);

    }

    

    return this._script;

  } 

  catch (ex) { 

    warn('Error while loading plugin: %s', this.name, ex.message, ex.stack);

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

  }

}


// ------------------------------------------

//  CACHE PLUGINS

// ------------------------------------------


var cache    = {};

var getCache = function(){ return cache;  }


var refresh = function(){

  

  cache = {};

  

  // Find config

  var keys = Object.keys(Config[TYPE_MODULES]);

  

  // Build a list of plugins

  for(var i = 0 ; i < keys.length ; i++){

    var key = keys[i];

    cache[key] = new Plugin ({'name' : key });

    cache[key].getInstance();

  }

  

  keys = Object.keys(Config[TYPE_PHANTOMS]);

  for(var i = 0 ; i < keys.length ; i++){

The variable i already seems to be declared on line 166. Consider using another variable name or omitting the var keyword.

    var key = keys[i];

The variable key already seems to be declared on line 167. Consider using another variable name or omitting the var keyword.

    if (cache[key]) continue;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    cache[key] = new Plugin ({'name' : key });

    cache[key].getInstance();

  }

  

  keys = Object.keys(Config[TYPE_CRON]);

  for(var i = 0 ; i < keys.length ; i++){

The variable i already seems to be declared on line 166. Consider using another variable name or omitting the var keyword.

    var key = keys[i];

The variable key already seems to be declared on line 167. Consider using another variable name or omitting the var keyword.

    if (cache[key]) continue;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    cache[key] = new Plugin ({'name' : key });

    cache[key].getInstance();

  }

}


// ------------------------------------------

//  PLUGIN LOCALES

// ------------------------------------------


var getLocales = function(locale){ 

  var prop   = {}

  var keys   = Object.keys(cache);

  for(var i  = 0 ; i < keys.length ; i++){

    var key  = keys[i];

    var json = cache[key].getLocale(locale);

    if (json){ extend(true, prop, json); }

  }

  return prop;  

}


// ------------------------------------------

//  PLUGIN LIST

// ------------------------------------------


var sort = function(ids, xPos, yPos){

  for(var i = 0 ; i < ids.length ; i++){

    var tmp = cache[ids[i]];

    if (tmp){

      var cfg = tmp.config;

      cfg.x = parseInt(xPos[i])+1;

      cfg.y = parseInt(yPos[i])+1;

    }

  }

  getList(true);

}


var getList = function(clean){ 

  

  if (clean){ refresh(); }

  

  var keys = Object.keys(cache);

  keys = keys.sort(function(k1, k2){

    var conf1 = cache[k1].config;

    var conf2 = cache[k2].config;

    

    if (!conf1.y) return  1;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    if (!conf2.y) return -1;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    

    if (conf1.y < conf2.y) return  -1;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    if (conf1.y > conf2.y) return   1;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    return conf1.x < conf2.x ? -1 : 1;

  });

  

  var list = [];

  for(var i = 0 ; i < keys.length ; i++){

    var key = keys[i];

    var plugin = cache[key];

    

    // Skip disabled plugin

    if (plugin.isDisabled()){ continue; }

    

    list.push(plugin);

  }

  return list;

}



// ------------------------------------------

//  FIND / SEEK

// ------------------------------------------


var find = function(name){

  return cache[name];

}


var exists = function(name){

  var plugin = find(name);

  return plugin ? true : false;

}


var remove = function(name, callback){

  var plugin = find(name);

  if (!plugin){ return callback(); }

  

  // Remove from filesystem

  var path = SARAH.ConfigManager.PLUGIN+'/'+name;

  info('Removing %s plugin...', path);

  if (fs.existsSync(path)){ fs.removeSync(path); }

  

  // Remove in memory

  refresh();

  

  callback();

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

}


// ------------------------------------------

//  EVENT

// ------------------------------------------


var events = require('events');

var ee = new events.EventEmitter();


var listen = function(event, callback){

  ee.on(event, callback);

}


var trigger = function(event, data){

  ee.emit(event, data);

}


var socket = function(io){

  io.on('connection', function(socket){

    socket.on('disconnect', function(){ });

    

    for(var name in cache){

      plugin = cache[name].getInstance();

      if (plugin.socket) plugin.socket(io, socket);

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    }

  });

}


// ------------------------------------------

//  ROUTER

// ------------------------------------------


var Router = express.Router();


Router.get('/plugin/help/:name', function(req, res, next) { 

  var name   = req.params.name; 

  var plugin = find(name);

  

  if (plugin && plugin.index) {

    return res.render(plugin.index, {'title' : i18n('modal.plugin.help', name)});

  }

  next();

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

});


Router.get('/plugin/github/:name', function(req, res, next) { 

  var name   = req.params.name; 

  SARAH.Marketplace.getCommits(name, function(commits){

    res.render('plugin/github.ejs', {

      'title'   : i18n('modal.plugin.github', name),

      'commits' : commits

    });

  });

});


Router.get('/plugin/config/:name', function(req, res, next) { 

  var name   = req.params.name; 

  return res.render('plugin/config.ejs', {'title' : i18n('modal.plugin.config', name) });

});


Router.post('/plugin/config/:name', function(req, res, next) { 

  var name    = req.params.name; 

  var plugin  = find(name);

  var keys    = Object.keys(req.body);

  for(var i   = 0 ; i < keys.length ; i++){

    var key   = keys[i];

    var value = Helper.parse(req.body[key]);

    var pfx   = key.substring(0, key.indexOf('.'));  

    var prop  = key.substring(key.indexOf('.')+1);

    

    // skip internal parameter like ajax 

    if (!pfx) continue;

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

    

    info('[%s] %s.%s.%s = %s',key, pfx, name, prop, value);

    Config[pfx][name][prop] = value;

  }

  SARAH.ConfigManager.save();


  var referer = req.headers.referer;

  if (referer && referer.indexOf('/portal') < 0){

    return res.redirect(referer);

  } else {

    return res.render('plugin/config.ejs', {'title' : i18n('modal.plugin.config', name), 'message' : true });

  }

});


Router.get('/plugin/edit/:name', function(req, res, next) { 

  var name   = req.params.name; 

  var plugin = find(name);

  return res.render('plugin/edit.ejs', {'title' : i18n('modal.plugin.edit', name)});

});


Router.all('/plugin/sort', function(req, res, next) { 

  sort(req.query.ids, req.query.xPos, req.query.yPos);

  SARAH.ConfigManager.save();

  res.end();

});


Router.all('/plugin/:name/*', function(req, res, next) {

  var name   = req.params.name;

  var plugin = find(name);

  if (!plugin) return res.end();

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

  

  var path = req.params[0];

  if (!path) return res.end();

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

  

  try {

    var fullpath = SARAH.ConfigManager.PLUGIN+'/'+name+'/'+path;

    if (fs.existsSync(fullpath)){ 

      res.render(fullpath, { "plugin" : plugin, "title" : (req.query.title || req.body.title || "") });

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

    } else {

      warn('path not found:', fullpath);

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

    }

  } 

  catch (ex){ 

    warn('Error' , fullpath, ex.stack); 

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

  }

});


Router.all('/plugin/:name*', function(req, res, next) { 

  var plugin = find(req.params.name);

  if (!plugin) return res.end();

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

  

  var render = function(){

    res.render('portal/portlet.ejs', { "plugin" : plugin});

  }

  

  var instance = plugin.getInstance();

  if (instance.ajax){ instance.ajax(req, res, render); } else { render(); }

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

});


Router.all('/static/:name/*', function(req, res, next) { 

  var plugin = find(req.params.name);

  if (!plugin) return res.end();

Curly braces around statements make for more readable code and help prevent bugs when you add further statements.

  

  var instance = plugin.getInstance();

  if (instance.route) { 

    instance.route(req, res, next); 

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

  } else { next(); }

There is no return statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding return undefined; explicitly.

});



// ------------------------------------------

//  PUBLIC

// ------------------------------------------


var PluginManager = {

  'init' : init,

  'getCache'      : getCache,

  'getList'       : getList,

  'getLocales'    : getLocales,

  

  'find'          : find,

  'exists'        : exists,

  'remove'        : remove,

  

  'socket'        : socket,            

  'trigger'       : trigger,

  'listen'        : listen,

  

  'Router'        : Router

}


// Exports Manager

exports.init = PluginManager.init;