@beauraines/rtm-cli 1.5.2

package/src/cmd/tags.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const log = require('../utils/log.js');
+const config = require('../utils/config.js');
+const filter = require('../utils/filter')
+const finish = require('../utils/finish.js');
+const styles = config.get().styles;
+
+/**
+ * This command lists all of the User's current RTM Task Tags
+ */
+function action(args, env) {
+  config.user(function(user) {
+    log.spinner.start("Getting Tags...");
+    
+    // Get Tasks
+    const filterString = filter('isTagged:true');
+    // TODO use a new fetch function that doesn't create RTM Tasks for everything returned
+    // TODO this should call the rtm.tags.getList, but then it wouldn't be able to show the task counts
+    user.tasks.get(filterString, function(err, tasks) {
+      if ( err ) {
+        log.spinner.error("Could not get tags (" + err.msg + ")");
+        return finish();
+      }
+      log.spinner.stop();
+
+      // List of Tags
+      let tags = [];
+
+      // Get Tags from Tasks
+      for ( let i = 0; i < tasks.length; i++ ) {
+        let task = tasks[i];
+        let _tags = task.tags;
+
+        // Parse Each Task's Tag
+        for ( let j = 0; j < _tags.length; j++ ) {
+          let _tag = _tags[j];
+
+          // Check for matching Tag
+          let found = false;
+          for ( let k = 0; k < tags.length; k++ ) {
+            if ( tags[k].name === _tag ) {
+              if ( task.isCompleted ) {
+                tags[k].completed = tags[k].completed + 1;
+              }
+              else {
+                tags[k].incomplete = tags[k].incomplete + 1;
+              }
+              tags[k].count = tags[k].count + 1;
+              found = true;
+            }
+          }
+
+          // Add new Tag
+          if ( !found ) {
+            tags.push({
+              name: _tag,
+              completed: task.isCompleted ? 1 : 0,
+              incomplete: task.isCompleted ? 0 : 1,
+              count: 1
+            });
+          }
+        }
+      }
+
+      // Get max tag length
+      let max = 0;
+      for ( let i = 0; i < tags.length; i++ ) {
+        let l = tags[i].name.length;
+        max = l > max ? l : max;
+      }
+
+      // Print Tags
+      for ( let i = 0; i < tags.length; i++ ) {
+        let tag = tags[i];
+        log.style(tag.name, styles.tags);
+
+        let delta = max - tag.name.length;
+        for ( let i = 0; i < delta + 1; i++ ) {
+          log.style(' ');
+        }
+
+        log.style(tag.incomplete);
+        log.style('/');
+        log.style(tag.completed, 'dim', true);
+      }
+
+      // Return
+      return finish();
+
+    });
+  });
+}
+
+
+module.exports = {
+  command: 'tags',
+  alias: 't',
+  description: 'Display all tags',
+  action: action
+};

package/src/cmd/uncomp.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const log = require('../utils/log.js');
+const config = require('../utils/config.js');
+const { prompt } = require('../utils/prompt.js');
+
+const finish = require('../utils/finish.js');
+
+
+/**
+ * This command marks 1 or more Tasks as complete
+ * @param args indices...
+ * @param env
+ */
+function action(args, env) {
+
+  // Prompt for tasks
+  if ( args.length === 0 ) {
+    prompt('Task:', _promptFinished);
+  }
+
+  // Process Tasks
+  else {
+    for ( let i = 0; i < args[0].length; i++ ) {
+      _process(args[0][i], i+1, args[0].length);
+    }
+  }
+
+}
+
+
+/**
+ * Process the returned answers
+ * @private
+ */
+function _promptFinished(answers) {
+  for ( let i = 0; i < answers.length; i++ ) {
+    let answer = answers[i];
+    _process(answer[0], i+1, answers.length);
+  }
+}
+
+
+/**
+ * Process the request
+ * @private
+ */
+function _process(task, count=1, max=1) {
+  log.spinner.start("Un-completing Task(s)...");
+  config.user(function(user) {
+    task = parseInt(task.trim());
+
+    // Complete Task
+    user.tasks.uncomplete(task, function(err) {
+      if ( err ) {
+        log.spinner.error("Could not un-complete Task #" + task + " (" + err.msg + ")");
+      }
+      _processFinished(count, max);
+    });
+
+  });
+}
+
+/**
+ * Request Callback
+ * @private
+ */
+function _processFinished(count, max) {
+  log.spinner.start("Un-completing Task [" + count + "/" + max + "]...");
+  if ( count === max ) {
+    log.spinner.success("Task(s) Un-Completed");
+    return finish();
+  }
+}
+
+
+module.exports = {
+  command: 'uncomp [indices...]',
+  alias: 'unc',
+  description: 'Mark one or more Tasks as not complete',
+  action: action
+};

package/src/cmd/url.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const log = require('../utils/log.js');
+const config = require('../utils/config.js');
+const finish = require('../utils/finish.js');
+const filter = require('../utils/filter');
+const { indexPrompt } = require('../utils/prompt')
+const opn = require('opn');
+
+
+let URLS = [];
+let OPEN = false;
+
+
+/**
+ * This command displays a task url
+ * @param args index
+ * @param env
+ */
+async function action(args, env) {
+
+  // Reset URLs
+  URLS = [];
+
+  // Set Open flag
+  OPEN = env.open === undefined ? false : env.open;
+
+  const user = config.user(user => user)
+
+  let indices = []
+
+  // Prompt for task
+  if ( args.length < 1 ) {
+    indices = indexPrompt('Task:')
+    args[0] = indices
+  }
+
+
+  log.spinner.start("Getting Task(s)");
+  // Use provided args
+  for (const arg in args[0]) {
+      if (Object.hasOwnProperty.call(args[0], arg)) {
+          const index = args[0][arg];
+          const filterString = filter('hasUrl:true');
+          let task =  await user.tasks.rtmIndexFetchTask(index,filterString)
+          if (task.err == undefined ) {
+              task = task.task
+          } else {
+            log.spinner.warn('Task #' + index + ' does not have a URL or is not found');
+          }
+
+          // Push to URLS
+          if ( task && task.url !== undefined ) {
+            URLS.push({
+            index: index,
+            url: task.url,
+            name: task.name
+            });
+          }         
+      }
+  }
+  // Print URLs
+  log.spinner.stop();
+  for ( let i = 0; i < URLS.length; i++ ) {
+      log(URLS[i].index + " " + URLS[i].name + " " + URLS[i].url);
+      }
+
+  // Open URL
+  if ( OPEN ) {
+    for ( let i = 0; i < URLS.length; i++ ) {
+      opn(URLS[i].url, {wait: false})//.then(function() {});
+    }
+  }
+  
+
+  finish()
+  
+
+}
+
+
+module.exports = {
+    command: 'url [indices...]',
+    options: [
+      {
+        option: "-o, --open",
+        description: "Open the URLs in a browser"
+      }
+    ],
+    description: 'Display the associated URL of a Task',
+    action: action
+  };

package/src/cmd/whoami.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const config = require('../utils/config.js');
+const finish = require('../utils/finish.js');
+const log = require('../utils/log.js');
+
+
+/**
+ * This command displays the user information of the logged in
+ * Remember the Milk account
+ */
+function action(args, env) {
+  let user = config.get()._user;
+  if ( user ) {
+    log("RTM ID: " + user.id);
+    log("Username: " + user.username);
+    log("Full Name: " + user.fullname);
+    log("RTM Auth Token: " + user.authToken);
+  }
+  else {
+    log.spinner.error("No User Information Found");
+    log.style("Use the ");
+    log.style("login", "bgYellow.black");
+    log.style(" command to login to RTM.");
+    log();
+  }
+  finish();
+}
+
+
+module.exports = {
+  command: 'whoami',
+  description: 'Display RTM user information',
+  action: action,
+  disableLogin: true
+};

package/src/interactive.js

@@ -0,0 +1,65 @@
+'use strict';
+
+
+/**
+ * Display the Interactive Mode Prompt
+ */
+function prompt() {
+  global._interactive = true;
+
+  // Display the Prompt
+  global._mainPrompt = true;
+  global._rl.question("> ", function(line) {
+    global._mainPrompt = false;
+
+    // Parse the command from the entered line
+    let params = line.trim().split(' ');
+    let cmd = params[0];
+    params.unshift(process.argv[0], process.argv[1]);
+
+    // Get possible commands
+    let commands = [];
+    let aliases = [];
+    for ( let i = 0; i < global._program.commands.length; i++ ) {
+      commands.push(global._program.commands[i].name());
+      if ( global._program.commands[i].alias() !== undefined ) {
+        aliases.push(global._program.commands[i].alias());
+      }
+    }
+
+    // Exit
+    if ( cmd === 'quit' || cmd === 'exit' ) {
+      global._rl.close();
+      process.exit(0);
+    }
+
+    // Help
+    else if ( cmd === 'help' ) {
+      global._program.outputHelp();
+      prompt();
+    }
+
+    // Parse the line command with commander
+    else if ( commands.indexOf(cmd) > -1 || aliases.indexOf(cmd) > -1 ) {
+      global._program.parse(params);
+    }
+
+    // Nothing entered
+    else if ( cmd === '' ) {
+      prompt();
+    }
+
+    // Unknown command
+    else {
+      const log = require('./utils/log.js');
+      log.spinner.error("Unknown Command");
+      log.style("Commands: help," + commands.join(',') + ",quit", "dim", true);
+      prompt();
+    }
+
+  });
+
+}
+
+
+module.exports = prompt;

package/src/utils/config.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const api = require('rtm-api');
+const merge = require('deepmerge');
+const login = require('./login.js');
+
+
+/**
+ * Default Configuration
+ */
+const BASE_CONFIG = path.normalize(__dirname + '/../../config.json');
+
+/**
+ * Default User Configuration
+ */
+let DEFAULT_USER_CONFIG = path.normalize(os.homedir() + '/.rtm.json');
+let DEFAULT_EXTRA_CONFIG = path.normalize(os.homedir() + '/.rtm.config.json');
+
+
+/**
+ * RTM CLI Configuration
+ */
+class Config {
+
+
+  /**
+   * Set up a new Configuration
+   */
+  constructor() {
+    this.reset(DEFAULT_USER_CONFIG);
+    this.read(DEFAULT_EXTRA_CONFIG);
+  }
+
+  /**
+   * Reset the RTM Configuration with the specified User config file
+   * @param {string} file User Config File
+   */
+  reset(file) {
+    this._CONFIG = {};
+    this.read(BASE_CONFIG);
+    this.read(file);
+    this.USER_CONFIG = file;
+  }
+
+
+  /**
+   * Get the Configuration Object
+   * @returns {object}
+   */
+  get() {
+    return this.config;
+  }
+
+  /**
+   * Get the Configuration Object
+   * @returns {object}
+   */
+  get config() {
+    if ( this._CONFIG === {} ) {
+      throw "No Configuration Set";
+    }
+    this._parseOptions();
+    return this._CONFIG;
+  }
+
+  /**
+   * Get the RTMClient from the configuration
+   * @returns {RTMClient}
+   */
+  get client() {
+    if ( !this._CONFIG._client ) {
+      throw "No Client configuration set";
+    }
+    return this._CONFIG._client;
+  }
+
+  /**
+   * Get the RTMUser from the configuration
+   *
+   * If no RTMUser is saved, start the login process
+   * @param {function} callback callback function
+   * @param {RTMUser} callback.user The RTM User
+   */
+  user(callback) {
+    if ( !this._CONFIG._user ) {
+      return login(callback);
+    }
+    return callback(this._CONFIG._user);
+  }
+
+
+  /**
+   * Read a configuration file to merge with the existing configuration
+   * @param {string} file Configuration file path
+   */
+  read(file) {
+    if ( file && fs.existsSync(file) ) {
+
+      // Read the config file
+      let config = JSON.parse(fs.readFileSync(file, 'utf-8'));
+
+      // Merge config into CONFIG
+      this._CONFIG = merge(this._CONFIG, config, {
+        arrayMerge: function (d, s) {
+          return d.concat(s);
+        }
+      });
+
+      // Parse the Config Object
+      this._parseConfig();
+
+    }
+  }
+
+
+  /**
+   * Save the RTM User to the user configuration file
+   * @param {RTMUser} user RTM User to save
+   */
+  saveUser(user) {
+    this._CONFIG._user = user;
+    let config = {};
+    if ( fs.existsSync(this.USER_CONFIG) ) {
+      config = JSON.parse(fs.readFileSync(this.USER_CONFIG, 'utf-8'));
+    }
+    config.user = this.client.user.export(user);
+    fs.writeFileSync(this.USER_CONFIG, JSON.stringify(config, null, 2));
+  }
+
+
+  /**
+   * Remove any saved RTM User information from the User config file
+   */
+  removeUser() {
+    if ( fs.existsSync(this.USER_CONFIG) ) {
+      let config = JSON.parse(fs.readFileSync(this.USER_CONFIG, 'utf-8'));
+      if ( config.user ) {
+        delete config.user;
+        fs.writeFileSync(this.USER_CONFIG, JSON.stringify(config, null, 2));
+      }
+    }
+    if ( this._CONFIG.user ) {
+      delete this._CONFIG.user;
+    }
+    if ( this._CONFIG._user ) {
+      delete this._CONFIG._user;
+    }
+  }
+
+
+  /**
+   * Parse the command line options (override from config files)
+   */
+  _parseOptions() {
+    if ( global._program ) {
+
+      // Parse plain & styled flags
+      if ( global._program.color ) {
+        this._CONFIG.plain = false;
+        delete global._program.color;
+      }
+      if ( global._program.plain ) {
+        this._CONFIG.plain = true;
+        delete global._program.plain;
+      }
+
+      // Parse completed
+      let completed = global._program.completed === undefined ? this._CONFIG.completed : global._program.completed;
+      if ( completed.toString().toLowerCase() === 'true' ) {
+        completed = true;
+      }
+      else if ( completed.toString().toLowerCase() === 'false' ) {
+        completed = false;
+      }
+      else {
+        completed = parseInt(completed);
+      }
+      this._CONFIG.completed = completed;
+
+      // Parse hide due
+      let hideDue = global._program.hideDue === undefined ? this._CONFIG.hideDue : global._program.hideDue;
+      if ( hideDue.toString().toLowerCase() === 'false' ) {
+        hideDue = false;
+      }
+      else {
+        hideDue = parseInt(hideDue);
+      }
+      this._CONFIG.hideDue = hideDue;
+
+      // Parse status
+      if ( global._program.status ) {
+        this._CONFIG.status = !this._CONFIG.status;
+        delete global._program.status;
+      }
+
+    }
+  }
+
+
+  /**
+   * Parse the Configuration properties
+   * @private
+   */
+  _parseConfig() {
+
+    // Reset CONFIG client and user
+    delete this._CONFIG._client;
+    delete this._CONFIG._user;
+
+    // Set the RTM Client
+    if ( this._CONFIG.client ) {
+      this._CONFIG._client = new api(
+        this._CONFIG.client.key,
+        this._CONFIG.client.secret,
+        this._CONFIG.client.perms
+      );
+    }
+
+    // Set the RTM User, if present
+    if ( this._CONFIG.user ) {
+      try {
+        this._CONFIG._user = this._CONFIG._client.user.import(this._CONFIG.user);
+      }
+      catch(exception) {}
+    }
+
+  }
+
+
+}
+
+
+module.exports = new Config();

package/src/utils/filter.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const config = require('../utils/config.js');
+
+
+/**
+ * Parse filter text to append preconfigured filter
+ * @param filter
+ */
+function filter(filter) {
+  if ( filter === undefined ) {
+    filter = '';
+  }
+
+  // Filters
+  let filters = [];
+
+  // Generate Completed Filter
+  let comp = config.get().completed;
+  if ( comp === false ) {
+    filters.push('(status:incomplete)');
+  }
+  else if ( comp !== true && comp > 0 ) {
+    filters.push('(status:incomplete OR completedWithin:"' + comp + ' days")');
+  }
+
+  // Generate Due Filter
+  let due = config.get().hideDue;
+  if ( typeof due === 'number' && due > 0 ) {
+    filters.push('(NOT dueAfter:"' + due + ' days")');
+  }
+
+  // Add user filter
+  if ( filter.trim() !== '' ) {
+    filters.push('(' + filter + ')');
+  }
+
+  // Join filters
+  return filters.join(' AND ');
+
+}
+
+module.exports = filter;

package/src/utils/finish.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const interactive = require('../interactive.js');
+
+
+/**
+ * This function is called when a command is finished.  It will
+ * return to an interactive prompt, if in interactive mode, or
+ * exit the process.
+ */
+function finish() {
+  if ( global._interactive ) {
+    interactive();
+  }
+  else {
+    process.exit(0);
+  }
+}
+
+
+module.exports = finish;

package/src/utils/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  config: require('./config.js'),
+  filter: require('./filter.js'),
+  finish: require('./finish.js'),
+  log: require('./log.js'),
+  login: require('./login.js'),
+  prompt: require('./prompt.js')
+};