@beauraines/rtm-api 1.4.1

package/src/utils/auth.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const RTMUser = require('../user/index.js');
+const sign = require('./sign.js');
+
+// API Configuration Properties
+const config = require('../../config');
+const scheme = config.api.scheme;
+const base = config.api.url.auth;
+
+
+/**
+ * Get Auth URL
+ * @param {RTMClient} client RTM Client making the request
+ * @param {function} callback Callback function(err, authUrl, frob)
+ * @private
+ */
+function getAuthUrl(client, callback) {
+
+  // Get a frob from the API Server
+  _getFrob(client, function(err, frob) {
+    if ( err ) {
+      return callback(err);
+    }
+
+    // Build the AUTH URL
+    let authUrl = _buildAuthURL(frob, client);
+
+    // Return the Auth URL
+    return callback(null, authUrl, frob);
+
+  });
+
+}
+
+
+/**
+ * Get Auth Token
+ * @param {string} frob RTM Frob, from {@link getAuthUrl}
+ * @param {RTMClient} client RTM Client making the request
+ * @param {function} callback Callback function(err, user)
+ * @private
+ */
+function getAuthToken(frob, client, callback) {
+
+  // Set request parameters
+  let params = {
+    frob: frob
+  };
+
+  // Get Auth Token
+  client.get('rtm.auth.getToken', params, function(err, resp) {
+    if ( err ) {
+      return callback(err);
+    }
+
+    // Create new RTMUser
+    let user = client.user.create(
+      resp.auth.user.id,
+      resp.auth.user.username,
+      resp.auth.user.fullname,
+      resp.auth.token
+    );
+
+    // Get a new Timeline for the User
+    user.get('rtm.timelines.create', function(err, resp) {
+      if ( err ) {
+        return callback(err);
+      }
+
+      // Set the User's Timeline
+      user.timeline = resp.timeline;
+
+      return callback(null, user);
+    });
+
+  });
+
+}
+
+
+/**
+ * Verify Auth Token
+ * @param {string|RTMUser} token RTM User Authentication Token or RTM User
+ * @param {RTMClient} client RTM Client making the request
+ * @param {function} callback Callback function(err, verified)
+ * @private
+ */
+ function verifyAuthToken(token, client, callback) {
+
+   // Get token from RTMUser
+   if ( typeof token === 'object' ) {
+     if ( token.constructor.name === 'RTMUser' ) {
+       token = token.authToken;
+     }
+   }
+
+  // Set request parameters
+  let params = {
+    auth_token: token
+  };
+
+  // Verify Token
+  client.get('rtm.auth.checkToken', params, function(err) {
+    if ( err) {
+      if ( err.code === 98 ) {
+        return callback(null, false);
+      }
+      else {
+        return callback(err);
+      }
+    }
+    else {
+      return callback(null, true);
+    }
+  });
+
+}
+
+
+
+// ==== HELPER FUNCTIONS ==== //
+
+
+/**
+ * Get RTM Authentication Frob
+ * @param {RTMClient} client RTM Client making the request
+ * @param {function} callback Callback function(err, frob)
+ * @private
+ */
+function _getFrob(client, callback) {
+
+  client.get('rtm.auth.getFrob', function(err, resp) {
+    if ( err ) {
+      return callback(err);
+    }
+    return callback(null, resp.frob);
+  });
+
+}
+
+/**
+ * Build the Authentication URL to send to the User
+ * @param {string} frob RTM Authentication Frob
+ * @param {RTMClient} client RTM Client making the request
+ * @returns {string} RTM Auth URL
+ * @private
+ */
+function _buildAuthURL(frob, client) {
+
+  // Build Request Parameters
+  let params = {};
+  params.api_key = client.key;
+  params.perms = client.perms;
+  params.frob = frob;
+  params.api_sig = sign(params, client);
+
+  // Form Query
+  let query = _formQuery(params);
+
+  // Build Auth URL
+  return scheme + '://' + base + '?' + query;
+
+}
+
+/**
+ * Generate a URI Encoded query string from the parameters set of key/value pairs
+ * @param {object} params Object containing the key/value parameters
+ * @returns {string} URL Encoded query string
+ * @private
+ */
+function _formQuery(params) {
+  let parts = [];
+  for ( let key in params ) {
+    if ( params.hasOwnProperty(key) ) {
+      parts.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key]));
+    }
+  }
+  return parts.join("&");
+}
+
+
+
+module.exports = {
+  getAuthUrl: getAuthUrl,
+  getAuthToken: getAuthToken,
+  verifyAuthToken: verifyAuthToken
+};

package/src/utils/fetch.js

@@ -0,0 +1,67 @@
+const fetch = require('node-fetch');
+const sign = require('../utils/sign')
+
+
+// API Configuration Properties
+const config = require('../../config');
+const scheme = config.api.scheme;
+const base = config.api.url.base;
+const format = config.api.format;
+const version = config.api.version;
+
+
+function buildUrl(user,filter) {
+  let query = {
+    filter: filter ,
+    auth_token: user._authToken,
+    method: 'rtm.tasks.getList',
+    api_key: user._client._apiKey,
+    v: version,
+    format
+  }
+
+  let apiSig=sign(query,{secret:user._client._apiSecret})
+
+  let url = `${scheme}://${base}?${formQuery(query)}&api_sig=${apiSig}`
+  return url
+}
+
+
+
+
+/**
+ * Generate a URI Encoded query string from the parameters set of
+ * key/value pairs
+ * @param {object} params Object containing the key/value parameters
+ * @returns {string} URL Encoded query string
+ */
+function formQuery(params) {
+let parts = [];
+for ( let key in params ) {
+    if ( params.hasOwnProperty(key) ) {
+    parts.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key]));
+    }
+}
+return parts.join("&");
+}
+
+/**
+ * 
+ * @param {string} url fully formed url to call
+ * @returns JSON response
+ */
+async function callAPI(url) {
+  try {
+      const response = await fetch(url);
+      if (await response.ok) {
+          return await response.json();
+      } else {
+          // TODO improve this error message
+          console.error('There was an error');
+      }
+    } catch (error) {
+        console.error(error)
+    }
+}
+
+module.exports = {callAPI,formQuery, buildUrl}

package/src/utils/get.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const URL = require('url');
+
+const parse = require('../response/parse.js');
+const error = require('../response/error.js');
+const RTMClient = require('../client/index.js');
+const RTMUser = require('../user/index.js');
+const sign = require('./sign.js');
+
+// API Configuration Properties
+const config = require('../../config');
+const scheme = config.api.scheme;
+const base = config.api.url.base;
+const format = config.api.format;
+const version = config.api.version;
+
+
+/**
+ * Make the specified RTM API call.
+ * @param {string} method RTM API Method
+ * @param {object} [params={}] RTM Method Parameters (as an object with key/value pairs)
+ * @param {RTMUser} [user=undefined] The RTM User making the request
+ * @param {RTMClient} [client=undefined] The RTM Client making the request
+ * @param {function} callback Callback function(err, resp)
+ * @private
+ */
+function get(method, params, user, client, callback) {
+
+  // Parse the given arguments
+  let args = _parseGetArgs(method, params, user, client, callback);
+
+  // Build the Request URL
+  let requestUrl = _buildRequestUrl(args.method, args.params, args.user, args.client);
+
+  // Parse the URL
+  let url = URL.parse(requestUrl);
+
+  // Build the request options
+  let options = {
+    host: url.host,
+    path: url.path,
+    method: 'GET'
+  };
+
+  // Determine timeout
+  let timeout = args.user ? args.user.requestTimeout : 0;
+
+  // Make the Request
+  setTimeout(function() {
+    _makeRequest(scheme, options, args.callback);
+  }, timeout);
+
+}
+
+/**
+ * Perform the API Request
+ * @param {string} scheme HTTP(s) Scheme (http or https)
+ * @param {object} options Request Options (host, path, method)
+ * @param {function} callback Final callback function(err, resp)
+ * @private
+ */
+function _makeRequest(scheme, options, callback) {
+
+  // Require the http(s) module
+  let http = undefined;
+  if ( scheme === "https" ) {
+    http = require('https');
+  }
+  else {
+    http = require('http');
+  }
+
+  // Make the Request
+  let req = http.request(options, function(response) {
+    let resp = '';
+    response.on('data', function(chunk) {
+      resp += chunk;
+    });
+    response.on('end', function() {
+      // Server Errors
+      if ( response.statusCode === 503 ) {
+        return callback(error.rateLimitError());
+      }
+      else if ( response.statusCode >= 500 && response.statusCode <= 599 ) {
+        return callback(error.serverError());
+      }
+
+      // Parse the API Response
+      let parsed = parse(resp);
+
+      // Return parsed result as error or success
+      if ( !parsed.isOk ) {
+        return callback(parsed)
+      }
+      else {
+        return callback(null, parsed);
+      }
+    });
+  });
+  req.on('error', function() {
+    callback(error.networkError());
+  });
+  req.end();
+
+}
+
+
+/**
+ * Parse the arguments given to the get() function
+ * @returns {{method: *, params: *, user: *, client: *, callback: *}}
+ * @private
+ */
+function _parseGetArgs() {
+
+  // Parsed arguments to return
+  let rtn = {};
+  rtn.params = {};
+
+  // Parse each of the arguments
+  for ( let key in arguments ) {
+    if ( arguments.hasOwnProperty(key) ) {
+      let arg = arguments[key];
+      if ( typeof arg === 'string' ) {
+        rtn.method = arg;
+      }
+      else if ( typeof arg === 'function' ) {
+        rtn.callback = arg;
+      }
+      else if ( typeof arg === 'object' ) {
+        if ( arg.constructor.name === 'RTMClient' ) {
+          rtn.client = arg;
+        }
+        else if ( arg.constructor.name === 'RTMUser' ) {
+          rtn.user = arg;
+        }
+        else {
+          rtn.params = arg;
+        }
+      }
+    }
+  }
+
+  // Return the parsed arguments
+  return rtn;
+
+}
+
+
+
+/**
+ * Build the API Request URL.
+ *
+ * This uses the properties in the `rtm.json` configuration file for the
+ * URL scheme, base URL, format and version.  It will create a URL encoded
+ * query string from the passed parameters and add a signature to the request.
+ * @param {string} method RTM API Method
+ * @param {Object} [params={}] Request Parameters
+ * @param {RTMUser} [user=undefined] The RTM User making the request
+ * @param {RTMClient} [client=undefined] The RTM Client making the request
+ * @returns {string} Signed Request URL
+ * @private
+ */
+function _buildRequestUrl(method, params, user, client) {
+
+  // Parse the given arguments
+  let args = _parseBuildRequestUrlArgs(method, params, user, client);
+
+  // Add User Auth Token, if provided
+  if ( args.user && args.user.authToken ) {
+    args.params.auth_token = args.user.authToken;
+  }
+
+  // Add method, api key, version and format to params
+  args.params.method = args.method;
+  args.params.api_key = args.client.key;
+  args.params.v = version;
+  args.params.format = format;
+  args.params.api_sig = sign(args.params, client);
+
+  // Generate query string from params
+  let query = _formQuery(args.params);
+
+  // Build the API request URL
+  return scheme + '://' + base + "?" + query;
+
+}
+
+
+/**
+ * Parse the arguments given to the _buildRequestUrl function
+ * @returns {{method: *, params: *, user: *, client: *}}
+ * @private
+ */
+function _parseBuildRequestUrlArgs() {
+
+  // Parsed arguments to return
+  let rtn = {};
+  rtn.params = {};
+
+  // Parse each of the arguments
+  for ( let key in arguments ) {
+    if ( arguments.hasOwnProperty(key) ) {
+      let arg = arguments[key];
+      if ( typeof arg === 'string' ) {
+        rtn.method = arg;
+      }
+      else if ( typeof arg === 'object' ) {
+        if ( arg.constructor.name === 'RTMClient' ) {
+          rtn.client = arg;
+        }
+        else if ( arg.constructor.name === 'RTMUser' ) {
+          rtn.user = arg;
+        }
+        else {
+          rtn.params = arg;
+        }
+      }
+    }
+  }
+
+  // Return the parsed arguments
+  return rtn;
+
+}
+
+
+/**
+ * Generate a URI Encoded query string from the parameters set of
+ * key/value pairs
+ * @param {object} params Object containing the key/value parameters
+ * @returns {string} URL Encoded query string
+ * @private
+ */
+function _formQuery(params) {
+  let parts = [];
+  for ( let key in params ) {
+    if ( params.hasOwnProperty(key) ) {
+      parts.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key]));
+    }
+  }
+  return parts.join("&");
+}
+
+
+
+module.exports = get;

package/src/utils/sign.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const crypto = require('crypto');
+
+
+/**
+ * ### RTM API Signature
+ *
+ * This module provides the `sign()` function which can be used to sign the RTM
+ * API requests for a given set of parameters and `RTMClient`.
+ *
+ * The parameters should be given as a single object with a set of
+ * key/value pairs as the object's properties.  For example, the
+ * parameters: `yxz=foo feg=bar abc=baz` should be given as on object
+ * as:
+ * ```
+ * {
+ *  yxz: "foo",
+ *  feg: "bar",
+ *  abc: "baz"
+ * }
+ * ```
+ * @module utils/sign
+ * @private
+ */
+
+
+/**
+ * Sign the RTM API Request
+ * @param {object} params Request parameters
+ * @param {RTMClient} client The RTM Client making the request
+ * @return {string} RTM API Signature
+ * @private
+ */
+function sign(params, client) {
+
+  // Sort the properties of the parameters
+  params = _sort(params);
+
+  // Concatenate the parameter's key/value pairs
+  let cat = _concat(params);
+
+  // Add to Shared Secret
+  let toHash = client.secret + cat;
+
+  // Return the Hash
+  return crypto.createHash('md5').update(toHash).digest("hex");
+
+}
+
+
+/**
+ * Sort the properties of the Object alphabetically
+ * @param {object} object Object to sort
+ * @returns {object} Object with sorted properties
+ * @private
+ */
+function _sort(object) {
+  let keys = [];
+  for ( let key in object ) {
+    if ( object.hasOwnProperty(key) ) {
+      keys.push(key);
+    }
+  }
+  keys.sort();
+
+  let rtn = {};
+  for ( let i = 0; i < keys.length; i++ ) {
+    let key = keys[i];
+    rtn[key] = object[key];
+  }
+  return rtn;
+}
+
+
+/**
+ * Concatenate the object's key/value pairs into a single string
+ * @param {object} object The object whose properties will be concatenated
+ * @returns {string} Concatenated key/value pairs
+ * @private
+ */
+function _concat(object) {
+  let rtn = "";
+  for ( let key in object ) {
+    if ( object.hasOwnProperty(key) ) {
+      rtn += key + object[key];
+    }
+  }
+  return rtn;
+}
+
+
+module.exports = sign;