[WIP] Implements show commands

lib/cli/input/show.js

@@ -0,0 +1,58 @@
+const inquirer = require('inquirer');
+const PromptGenerator = require('../../utils/PromptGenerator');
+
+const getPromptGenerator = (name, type, message) => {
+  const promptGenerator = new PromptGenerator();
+  promptGenerator.addProperty('name', name);
+  promptGenerator.addProperty('type', type);
+  promptGenerator.addProperty('message', message);
+  return promptGenerator;
+};
+
+const getScorePrompt = async () => {
+  const prompts = [
+    getPromptGenerator('lab', 'input', 'Enter the lab whose score has to be shown:').getPrompt(),
+    getPromptGenerator('id', 'input', 'Enter the student id: (optional)').getPrompt(),
+  ];
+  const scoreOptions = await inquirer.prompt(prompts);
+  return {
+    name: 'score',
+    details: {
+      lab: scoreOptions.lab,
+      id: scoreOptions.id,
+    },
+  };
+};
+
+const getScoreOptions = (options) => {
+  const lab = options.l;
+  const id = options.i;
+  if (!lab) {
+    return getScorePrompt();
+  }
+  return {
+    name: 'score',
+    details: {
+      lab, id,
+    },
+  };
+};
+
+const getInput = async (args, options) => {
+  switch (args.statistic) {
+    case 'status':
+      return {
+        name: 'status',
+      };
+    case 'score':
+      return getScoreOptions(options);
+    default:
+      return {
+        name: 'invalid_command',
+      };
+  }
+};
+
+module.exports = {
+  getInput,
+};

lib/cli/output/show.js

@@ -0,0 +1,101 @@
+const _ = require('lodash');
+const chalk = require('chalk');
+const childProcess = require('child_process');
+const fs = require('fs-extra');
+const Table = require('cli-table');
+const { Spinner } = require('cli-spinner');
+const util = require('util');
+
+const spinner = new Spinner('Fetching request results, please wait...');
+const startSpinner = () => {
+  spinner.setSpinnerString(0);
+  spinner.start();
+};
+
+const stopSpinner = () => {
+  spinner.stop();
+};
+
+const showScoreLess = async (scoreboard) => {
+  const file = '/tmp/autolabjs/scoreboard';
+  try {
+    await fs.outputFile(file, scoreboard);
+    childProcess.spawn('cat /tmp/autolabjs/scoreboard | less -r', {
+      stdio: 'inherit',
+      shell: true,
+    });
+    console.log('\n');
+  } catch (err) {
+    console.log(chalk.red('Can not display scores due to filesystem error. Try again.'));
+  }
+};
+
+const showScore = (details) => {
+  const { scores } = details;
+  const posColWidth = 10;
+  const idColWidth = 15;
+  const scoreColWidth = 10;
+  const timeColWidth = 23;
+
+  const threshold = 1;
+
+  const table = new Table({
+    head: ['Position', 'ID Number', 'Score', 'Time'],
+    colWidths: [posColWidth, idColWidth, scoreColWidth, timeColWidth],
+  });
+
+  const scoreboard = _.zipWith(scores, _.range(1, scores.length + 1), (score, position) => {
+    score.unshift(position);
+    return _.map(score, val => val || '');
+  });
+
+  table.push(...scoreboard);
+  if (scores.length <= threshold) {
+    console.log(`\n${table.toString()}`);
+  } else {
+    showScoreLess(table.toString());
+  }
+};
+
+const handleHttpFailure = (details) => {
+  const httpError = 4;
+  if (details.code === httpError) {
+    console.log(chalk.red('\nPlease check your network connection'));
+  } else {
+    console.log(chalk.red('\nInvalid query'));
+  }
+};
+
+const sendOutput = async (event) => {
+  const lineBreakLength = 80;
+  switch (event.name) {
+    case 'fetching_results':
+      startSpinner();
+      break;
+    case 'status':
+      stopSpinner();
+      console.log(`\n${util.inspect(event.details.status,
+        { compact: true, breakLength: lineBreakLength, colors: true })}`);
+      break;
+    case 'score':
+      stopSpinner();
+      await showScore(event.details);
+      break;
+    case 'invalid_lab':
+      stopSpinner();
+      console.log(chalk.red('\nInvalid Lab'));
+      break;
+    case 'httpFailure':
+      stopSpinner();
+      handleHttpFailure(event.details);
+      break;
+    default:
+      stopSpinner();
+      console.log(chalk.red('\nInvalid Event'));
+      break;
+  }
+};
+
+module.exports = {
+  sendOutput,
+};

lib/controller/index.js

@@ -6,6 +6,7 @@ const init = require('./init');
 const exit = require('./exit');
 const prefs = require('./prefs');
 const evaluate = require('./eval');
+const show = require('./show');
 
 
 const start = async () => {
@@ -21,6 +22,7 @@ const start = async () => {
   exit.addTo(program);
   prefs.addTo(program);
   evaluate.addTo(program);
+  show.addTo(program);
 
   await program.parse(process.argv);
 };

lib/controller/show.js

@@ -0,0 +1,36 @@
+const showInput = require('../cli/input/show');
+const showOutput = require('../cli/output/show');
+const showModel = require('../model/show');
+
+const showValidate = require('./validate/show');
+
+const onShowResults = (showResult) => {
+  showOutput.sendOutput(showResult);
+};
+
+const onShow = async (args, options, logger) => {
+  logger.moduleLog('info', 'Show', 'Show command invoked.');
+
+  const showOptions = await showInput.getInput(args, options);
+  const validatedOptions = showValidate.validate(showOptions);
+
+  logger.moduleLog('debug', 'Show', 'Show request for');
+  logger.moduleLog('debug', 'Show', validatedOptions);
+
+  showOutput.sendOutput({ name: 'fetching_results' });
+
+  showModel.show(validatedOptions, onShowResults);
+};
+
+const addTo = (program) => {
+  program
+    .command('show', 'Shows server status and lab scores')
+    .argument('<statistic>', 'Argument for show command')
+    .option('-l <lab>', 'Lab to show score')
+    .option('-i <id>', 'Student ID to show the score')
+    .action(onShow);
+};
+
+module.exports = {
+  addTo,
+};

lib/controller/validate/show.js

@@ -0,0 +1,21 @@
+const validateScoreEvent = (event) => {
+  if (!event.details.lab) {
+    return {
+      name: 'invalid_options',
+    };
+  }
+  return event;
+};
+
+const validate = (showEvent) => {
+  switch (showEvent.name) {
+    case 'score':
+      return validateScoreEvent(showEvent);
+    default:
+      return showEvent;
+  }
+};
+
+module.exports = {
+  validate,
+};

lib/model/show.js

@@ -0,0 +1,106 @@
+const requestPromise = require('request-promise');
+const _ = require('lodash');
+const preferenceManager = require('../utils/preference-manager');
+const { logger } = require('../utils/logger');
+
+const fetchQuery = async (host, port, query) => {
+  const options = {
+    method: 'GET',
+    uri: `https://${host}:${port}${query}`,
+    rejectUnauthorized: false,
+  };
+
+  logger.moduleLog('debug', 'Show Model', `GET request to ${options.uri}`);
+
+  return requestPromise(options).json();
+};
+
+const getErrorMessage = (e) => {
+  const httpError = 4;
+  logger.moduleLog('error', 'Init Model', `Error ; ${e || httpError}`);
+  return {
+    name: 'httpFailure',
+    details: {
+      code: e.statusCode || httpError,
+    },
+  };
+};
+
+const getStatus = async (callback) => {
+  let response;
+  const { host, port } = preferenceManager.getPreference({ name: 'cliPrefs' }).main_server;
+  try {
+    const status = await fetchQuery(host, port, '/status');
+    logger.moduleLog('debug', 'Show Model', 'Fetched status..');
+    logger.moduleLog('debug', 'Show Model', status);
+    response = {
+      name: 'status',
+      details: {
+        status,
+      },
+    };
+  } catch (e) {
+    response = getErrorMessage(e);
+  }
+
+  callback(response);
+};
+
+const getFormattedScores = (scores, id) => {
+  if (scores === false) {
+    logger.moduleLog('debug', 'Show Model', 'Invalid lab');
+    return {
+      name: 'invalid_lab',
+    };
+  }
+  let filteredScores = scores;
+  if (id) {
+    filteredScores = _.find(scores, ['id_no', id]);
+    return {
+      name: 'score',
+      details: {
+        scores: [_.values(filteredScores)],
+      },
+    };
+  }
+  return {
+    name: 'score',
+    details: {
+      scores: _.map(filteredScores, _.values),
+    },
+  };
+};
+
+const getScore = async (options, callback) => {
+  const { lab, id } = options;
+
+  let response;
+  const { host, port } = preferenceManager.getPreference({ name: 'cliPrefs' }).main_server;
+  try {
+    const scores = await fetchQuery(host, port, `/scoreboard/${lab}`);
+    logger.moduleLog('debug', 'Show Model', `Fetched scores for ${lab}`);
+    response = getFormattedScores(scores, id);
+  } catch (e) {
+    response = getErrorMessage(e);
+  }
+
+  callback(response);
+};
+
+const show = (options, callback) => {
+  switch (options.name) {
+    case 'status':
+      getStatus(callback);
+      break;
+    case 'score':
+      getScore(options.details, callback);
+      break;
+    default:
+      callback(options);
+      break;
+  }
+};
+
+module.exports = {
+  show,
+};