dashboard.js

var util = require('util')
  , httpUtil = require('deployd/lib/util/http')
  , filed = require('filed-mimefix')
  , Resource = require('deployd/lib/resource')
  , path = require('path')
  , debug = require('debug')('dashboard')
  , fs = require('fs')
  , ejs = require('ejs')
  , loadTypes = require('deployd/lib/type-loader')
  , async = require('async');

function Dashboard(name, options) {
  // internal resource
  this.internal = true;

  this.loadTypes = async.memoize(this.loadTypes);
  this.loadLayout = async.memoize(this.loadLayout);

  Resource.apply(this, arguments);
}
util.inherits(Dashboard, Resource);
module.exports = Dashboard;

Dashboard.selfHost = function(options) {
  return new Dashboard('dashboard', options);
}

Dashboard.prototype.handle = function(ctx, next) {
  if (ctx.req.url === this.path) {
    return httpUtil.redirect(ctx.res, ctx.req.url + '/');
  } else if (ctx.url === '/__is-root') {
    ctx.done(null, {isRoot: ctx.req.isRoot});
  } else if (ctx.url.indexOf('/__custom') === 0) {
    this.serveCustomAsset(ctx, next);
  } else if (ctx.url.indexOf('.') !== -1) {
    filed(path.join(__dirname, 'dashboard', ctx.url)).pipe(ctx.res);
  } else if (!ctx.req.isRoot && (!ctx.server.options || ctx.server.options.env !== 'development')) {
    filed(path.join(__dirname, 'dashboard', 'auth.html')).pipe(ctx.res);
  } else {
    this.render(ctx);
  }

};


Dashboard.prototype.serveCustomAsset = function(ctx, next) {
  var parts = ctx.url.split('/').filter(function(p) { return p; })
    , resourceTypePath = parts[1]
    , resource = this;

  resource.loadTypes(function(err, types) {
    var resourceTypeId
      , resourceType
      , dashboardPath
      , reqUrl = parts.slice(2).join('/');

    resourceTypeId = Object.keys(types).filter(function(t) { return t.toLowerCase() === resourceTypePath; })[0];

    if (resourceTypeId) {
      resourceType = types[resourceTypeId];
      dashboardPath = resourceType && resourceType.dashboard && resourceType.dashboard.path;
      if (dashboardPath) {
        return filed(path.join(dashboardPath, reqUrl)).pipe(ctx.res);
      }
    }

    next();
  });
};

Dashboard.prototype.loadTypes = function(fn) {
  loadTypes(function(defaults, types) {
    Object.keys(defaults).forEach(function(key) {
      types[key] = defaults[key];
    });
    fn(null, types);
  });
};

Dashboard.prototype.render = function(ctx) {
  var self = this
    , appName = path.basename(path.resolve('./'))
    , env = ctx.server && ctx.server.options && ctx.server.options.env;

  async.parallel({
      layout: self.loadLayout
    , options: async.apply(self.loadPage.bind(self), ctx)
  }, function(err, results) {
    if (err) return ctx.done(err);

    var options = results.options || {}
      , layout = results.layout
      , render = {};

    var context = {
        resourceId: options.resourceId
      , resourceType: options.resourceType
      , page: options.page
      , basicDashboard: options.basicDashboard
      , events: options.events
      , appName: appName
      , env: env
    };

    render.bodyHtml = options.bodyHtml;

    try {
      var rendered = layout({context: context, render: render, scripts: options.scripts || [], css: options.css || null, version: require('./package.json').version});
      ctx.res.setHeader('Content-Type', 'text/html; charset=UTF-8');
      ctx.res.end(rendered);
    } catch (ex) {
      ctx.done(ex.message);
    }
  });
};

Dashboard.prototype.loadLayout = function(fn) {

  fs.readFile(path.join(__dirname, 'dashboard', 'index.ejs'), 'utf-8', function(err, layout) {
    if (err) return fn(err);
    var layoutTemplate = ejs.compile(layout, {delimiter:'?'}); //Avoid conlicts by using non-standard tags
    fn(null, layoutTemplate);
  });
};

Dashboard.prototype.loadPage = function(ctx, fn) {
  var parts = ctx.url.split('/').filter(function(p) { return p; })
    , resourceId
    , resource
    , resourceType
    , options = {}
    , self = this
    , dashboardPath
    , pagePath
    , page;
  if (parts.length) {
    if (/\/$/.test(ctx.url)) {
      // if the url ends with a slash, we have a page
      resourceId = parts.slice(0, parts.length - 1).join('/') || parts[0];
      page = parts.length > 1 ? parts.slice(-1)[0] : null;
    } else {
      // otherwise, the resource is the full url
      resourceId = parts.join('/');
    }
    
    resource = ctx.server.resources.filter(function(r) { return r.name === resourceId.toLowerCase() })[0];

    if (resource) {
      options.resourceId = resourceId;
      resourceType = resource.constructor;
      options.resourceType = resourceType.name;
      options.events = resourceType.events;
      options.scripts = [];


      if (!page && resourceType.dashboard && resourceType.dashboard.pages) {
        page = resourceType.dashboard.pages[0];
      } else if (!page) {
        page = 'index';
      }
      if (page === 'config') page = 'index';

      dashboardPath = resourceType.dashboard && resourceType.dashboard.path;

      async.waterfall([
        function(fn) {
          if (dashboardPath) {
            pagePath = path.join(dashboardPath, page + '.html');
            fs.exists(pagePath, function(exists) {
              fn(null, exists);
            });
          } else {
            fn(null, false);
          }
        },

        function(exists, fn) {
          if (exists) {
            self.loadAdvancedDashboard({
                pagePath: pagePath
              , dashboardPath: dashboardPath
              , page: page
              , resourceType: resourceType
              , options: options
            }, fn);
          } else {
            self.loadBasicDashboard({
                options: options
              , page: page
              , resourceType: resourceType
            }, fn);
          }
        }
      ], function(err) {
        fn(err, options);
      });

      debug("Editing resource %s of type %s", resourceId, resourceType.name);

      return;
    }
  }

  fn(); //blank page
};

Dashboard.prototype.loadAdvancedDashboard = function(data, fn) {
  var pagePath = data.pagePath
    , dashboardPath = data.dashboardPath
    , page = data.page
    , resourceType = data.resourceType
    , options = data.options;


  async.parallel({
    bodyHtml: function(fn) {
      fs.readFile(pagePath, 'utf-8', fn);
    },

    scripts: function(fn) {
      if (resourceType.dashboard.scripts) {
        resourceType.dashboard.scripts.forEach(function(s) {
          options.scripts.push('/__custom/' + resourceType.name.toLowerCase() + s);
        });
      }

      fs.exists(path.join(dashboardPath, 'js', page + '.js'), function(exists) {
        if (exists) {
          options.scripts.push('/__custom/' + resourceType.name.toLowerCase() + '/js/' + page + '.js');
        }

        fn();
      });
    },

    stylesheet: function(fn) {
      fs.exists(path.join(resourceType.dashboard.path, 'style.css'), function(exists) {
        if (exists) {
          options.css = '/__custom/' + resourceType.name.toLowerCase() + '/style.css';
        }

        fn();
      });
    }
  }, function(err, results) {
    if (err) return fn(err);

    options.bodyHtml = results.bodyHtml;

    if (page === 'index') page = 'config';
    options.page = page;

    fn(null, options);
  });
};

Dashboard.prototype.loadBasicDashboard = function(data, fn) {
  var options = data.options
    , page = data.page
    , resourceType = data.resourceType
    , dashboardPath = path.join(__dirname, 'dashboard');

  options.page = page;
  if (page === 'index') {
    options.page = 'config';
    if (resourceType.basicDashboard) {
      options.scripts.push('/js/basic.js');
      options.basicDashboard = resourceType.basicDashboard;
      fs.readFile(path.join(dashboardPath, 'basic.html'), function(err, bodyHtml) {
        options.bodyHtml = bodyHtml;
        fn(err);
      });
    } else {
      options.scripts.push('/js/default.js');
      fs.readFile(path.join(dashboardPath, 'default.html'), function(err, bodyHtml) {
        options.bodyHtml = bodyHtml;
        fn(err);
      });
    }
  } else if (page === 'events') {
    fs.readFile(path.join(dashboardPath, 'events.html'), function(err, bodyHtml) {
      options.bodyHtml = bodyHtml;
      fn(err);
    });
  } else {
    return fn();
  }
};