yoanm / alfred-personal-assistant

server/config.js

var fs      = require('fs');

var extend  = require('extend');

var express = require('express');

var request = require('request');


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

//  CONSTRUCTOR

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


var init = function(){

  info('Starting ConfigManager ...');

  

  // Load properties

  load();

  

  // Configure proxy

  if (Config.http.proxy){

    request.defaults({'proxy': Config.http.proxy})

  }

  

  // Expose properties to global

  global.Config = Config;

  

  return ConfigManager;

}


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

//  CONFIG

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

var path   = require('path');

var ROOT   = path.normalize(__dirname+'/..');

Consider using the path module for constructing paths since they are otherwise not cross-OS compatible.

var SERVER = path.normalize(ROOT+'/server/server.prop');

var PLUGIN = process.env.PLUGINS_PATH || path.normalize(ROOT+'/../../plugins');

var VIEW   = path.normalize(ROOT+'/webapp/views');

var CUSTOM = path.normalize(ROOT+'/data/custom.prop');


info('ROOT', ROOT, '\nSERVER', SERVER, '\nPLUGIN', PLUGIN);


info('NODE_PATH', module.paths);


var Config = { 'debug' : false };

var load = function(){

  try { 

    extend(true, Config, loadProperties());

    extend(true, Config, loadPlugins());

    extend(true, Config, loadCustoms());

    Config.bot.version = "4.0";

  } 

  catch(ex) { error('Error while loading properties: %s', ex.message);  }

  return ConfigManager;

}


/**

 * Load default properties

 */

var loadProperties = function(){

  if (!fs.existsSync(SERVER)) { return {}; }

  info('Loading server properties...', SERVER);

  var json = fs.readFileSync(SERVER, 'utf8');

  return JSON.parse(json);

}


/**

 * Load plugin properties recursively

 */

var loadPlugins = function(folder, json){ 

  var json   = json   || {};

  var folder = folder || PLUGIN;


  if (!fs.existsSync(folder)) { return json; }  

  fs.readdirSync(folder).forEach(function(file){

    var path = folder+'/'+file;

    

    // Directory

    if (fs.statSync(path).isDirectory()){

      loadPlugins(path, json);

      return json;

    }

    

    // Ends with .prop

    if (file.endsWith('.prop')){

There is no return statement if file.endsWith(".prop") is false. Are you sure this is correct? If so, consider adding return; explicitly.

      info('Loading plugin properties... %s', path);

      try {

        var load   =  fs.readFileSync(path,'utf8');

        var plugin = JSON.parse(load);

        extend(true, json, plugin);

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){ error('Error in %s: %s', file, ex.message); }

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.

    }

  });

  return json;

}


/**

 * Load custom properties

 */

var loadCustoms = function(){

  if (!fs.existsSync(CUSTOM)) { warn("Can't load custom properties !", CUSTOM); return {}; }

  info('Loading custom properties...', CUSTOM);

  

  var load = fs.readFileSync(CUSTOM,'utf8');

  var json = {}; 

The assignment to variable json seems to be never used. Consider removing it.

  try { json = JSON.parse(load); } catch (ex){ error('Error in custom.prop: %s', ex.message); }

  

  json['modules']  = retains(json['modules'],  Config['modules']);

  json['phantoms'] = retains(json['phantoms'], Config['phantoms']);

  json['cron']     = retains(json['cron'],     Config['cron']);


  return json;

}


var retains = function(source, target){

  if (typeof source != 'object') return source;

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

  

  var clean  = {};

  Object.keys(source).forEach(function(attr){

    if (attr == 'description' || attr == 'version'){ return false; }

    if (target[attr] === undefined

        && attr != 'x' && attr != 'y' 

        && attr != 'w' && attr != 'h'

        && attr != 'c' && attr != 'disabled'){ return warn('Skip config: %s', attr); }

    clean[attr] = retains(source[attr], target[attr]);

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.

  });

  

  return clean;

}


/**

 * Load plugin properties file

 */

var loadJSON = function(name){

  var path = PLUGIN+'/'+name+'/'+name+'.prop';

  if (!fs.existsSync(path)){ return {}; }

  info('Loading plugin properties... %s', path);

  try {

    var json = fs.readFileSync(path,'utf8');

    return JSON.parse(json);

  } catch(ex){ error('Error in %s: %s', name+'.prop', ex.message); }

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.

}


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

//  SAVE

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


var setProperty = function(keys, value, json){

  var config = json || Config;

  var keys = keys.split('.');

  for (var k in keys){

A for in loop automatically includes the property of any prototype object, consider checking the key using hasOwnProperty.

    var key = keys[k];

    if (typeof config[key] === 'object' ){

      config = config[key];

    } else {

      config[key] = value;

    }

  }

}


var save = function(cfg) {

  try {

    Config = cfg || Config;

    var json = JSON.stringify(Config, undefined, 2);


    //json = json.replace(/\{/g,"{\n  ").replace(/\}/g,"\n  }").replace(/,/g,",\n  ");

    fs.writeFileSync(CUSTOM, json, 'utf8');

    info('Properties saved successfully');

  } catch(ex) {

    error('Error while saving properties: %s', ex.message);

  }

}


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

//  ROUTER

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



var Router = express.Router();


Router.get('/portal/config', function(req, res, next) {

The parameter next is not used and could be removed.

  res.render('portal/config.ejs');

});


Router.post('/portal/config', function(req, res, next) {

The parameter next is not used and could be removed.

  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]);

The variable Helper seems to be never declared. If this is a global, consider adding a /** global: Helper */ comment.

    setProperty(key, value);

  }

  SARAH.ConfigManager.save();

The variable SARAH seems to be never declared. If this is a global, consider adding a /** global: SARAH */ comment.

  res.redirect('/portal/config');

});


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

//  PUBLIC

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


var ConfigManager = {

  'init'   : init,

  'load'   : load,

  'save'   : save,

  

  'loadJSON' : loadJSON,

  'getConfig': function(){ warn('getConfig is deprecated for SARAH 4.x, use global Config'); return Config; },

  'Router' : Router,

  'Config' : Config,

  'PLUGIN' : PLUGIN,

  'ROOT'   : ROOT,

  'VIEW'   : VIEW

}


// Exports Manager

exports.init = ConfigManager.init;