joola.io.engine/routes/dimensions.js

joola.io's Framework Engine

/**
 *  joola.io
 *
 *  Copyright Joola Smart Solutions, Ltd. <info@joo.la>
 *
 *  Licensed under GNU General Public License 3.0 or later.
 *  Some rights reserved. See LICENSE, AUTHORS.
 *
 *  @license GPL-3.0+ <http://spdx.org/licenses/GPL-3.0+>
 */

var
  router = require('./index'),

  url = require('url'),

  _dimensions = require('../lib/objects/dimensions'),
  _datatables = require('../lib/objects/datatables'),
  _datasources = require('../lib/objects/datasources'),
  auth = require('../lib/auth/manager'),
  connector = require('../lib/connectors/connector');

/**
 * Lists all available dimensions. You can provide parameters and ask for a specific data source and datatable.
 *
 * The returned list will contain only dimensions authorized for the authenticated user.
 *
 * @method list
 * @param {string} [datasourceid] Datasource ID.
 * @param {string} [datatableid] Datatable ID.
 * @return {object} json structure listing all dimensions.
 */
exports.index = exports.list = {
  name: 'dimensions/list',
  description: 'i list all dimensions available',
  inputs: {
    required: [],
    optional: ['datasourceid', 'datatableid']
  },
  outputExample: {},
  permission: ['access_system'],
  run: function (req, res) {
    var response = {};
    if (!req.user)
      return router.responseError(new router.AuthErrorTemplate('Missing user token'), req, res);

    var dimensions = _dimensions.list(req.params.datasourceid, req.params.datatableid);
    if (!dimensions)
      return router.responseError(new router.ErrorTemplate('Failed to find dimension'), req, res);
    else {
      var __dimensions = [];
      _.each(dimensions, function (d) {
        if (auth.hasRole(d.roles, req.user._roles)) {
          __dimensions.push(d);
        }
      });
      response.dimensions = __dimensions;
      return router.responseSuccess(response, req, res);
    }
  }
};

/**
 * Lists all available dimensions. You can provide parameters and ask for a specific data source and datatable.
 *
 * The returned list will contain only dimensions authorized for the authenticated user.
 *
 * @method get
 * @param {string} [dimensionid] Dimension ID.
 * @return {object} json structure holding the dimension details.
 */
exports.get = {
  name: 'dimensions/get',
  description: 'i get a specific dimension',
  inputs: {
    required: ['id'],
    optional: []
  },
  outputExample: {},
  permission: ['access_system'],
  run: function (req, res) {
    var response = {};
    response.dimension = null;

    if (!req.user)
      return router.responseError(new router.AuthErrorTemplate('Missing user token'), req, res);

    var dimension = _dimensions.get(req.params.id);
    if (!dimension)
      return router.responseError(new router.ErrorTemplate('Failed to find dimension'), req, res);


    if (auth.hasRole(dimension.roles, connection.user._roles))
      response.dimension = dimension;

    return router.responseSuccess(response, req, res);
  }
};

/**
 * Validates the dimension database integrity.
 *
 * @method get
 * @param {string} [dimensionid] Dimension ID.
 * @return {object} json structure holding the validation details.
 */
exports.validate = {
  name: 'dimensions/validate',
  description: 'i validate a specific dimension',
  inputs: {
    required: ['dimensionid'],
    optional: []
  },
  outputExample: {},
  permission: ['manage_system'],
  run: function (req,res) {
    var response = {};

    var dimension = _dimensions.get(req.params.dimensionid);
    var datatable = _datatables.get(dimension.datatableid);
    var datasource = _datasources.get(datatable.datasourceid);
    var query = connector.createQuery();

    response.dimension = ce.clone(dimension);
    response.validated = false;

    query.sql = 'SELECT ' + dimension.column + ' FROM ' + datatable.name + ';';
    query.limit = 1;
    query.datasource = datasource;
    connector.executeQuery(query, function (query, rows, fields, error) {
      response.queryInformation = ce.clone(query);
      if (error)
        throw error;
      else {
        response.validated = true;
      }

      return router.responseSuccess(response, req, res);
    });
  }
};

exports.values = {
  name: 'dimensions/values',
  description: 'i query for all values available for a dimension (limit 100)',
  inputs: {
    required: ['dimensionid'],
    optional: []
  },
  outputExample: {},
  permission: ['manage_system'],
  run: function (req, res) {
    var response = {};
    var dimension = _dimensions.get(connection.params.dimensionid);
    var datatable = _datatables.get(dimension.datatableid);
    var datasource = _datasources.get(datatable.datasourceid);
    var query = connector.createQuery();

    response.dimension = ce.clone(dimension);

    query.sql = 'SELECT ' + dimension.column + ' FROM ' + datatable.name + ';';
    query.limit = 100;
    query.datasource = datasource;
    connector.executeQuery(query, function (query, rows, fields, error) {
      response.queryInformation = ce.clone(query);
      if (error)
        throw error;
      else {
        response.values = [];
        if (typeof(rows) == 'Array') {
          rows.forEach(function (row) {
            response.values.push(row[dimension.column]);
          })
        }
      }
      router.responseSuccess(response, req, res);
    });
  }
};