task/helper.js

  1. 'use strict';
  3. const RTMTask = require('./index.js');
  4. const taskIds = require('../utils/taskIds.js');
  6. /**
  7.  * API Call: rtm.tasks.getList
  8.  * @param user RTMUser
  9.  * @param [filter] Task Filter
  10.  * @param callback Callback function(err, tasks)
  11.  * @private
  12.  */
  13. function get(user, filter, callback) {
  14.   let params = {};
  15.   if ( callback === undefined && typeof filter === 'function' ) {
  16.     callback = filter;
  17.   }
  18.   else if ( filter !== '' ) {
  19.     params.filter = filter;
  20.   }
  22.   user.get('rtm.tasks.getList', params, function(err, resp) {
  23.     if ( err ) {
  24.       return callback(err);
  25.     }
  27.     // List of task to return
  28.     let rtn = [];
  30.     // Parse each List
  31.     let lists = resp.tasks.list;
  32.     if ( lists !== undefined ) {
  33.       for ( let i = 0; i < lists.length; i++ ) {
  34.         let list = lists[i];
  36.         // Parse the List's TaskSeries
  37.         if ( list.taskseries ) {
  38.           if ( !Array.isArray(list.taskseries) ) {
  39.             list.taskseries = [list.taskseries];
  40.           }
  41.           for ( let j = 0; j < list.taskseries.length; j++ ) {
  42.             let series = list.taskseries[j];
  43.             if ( series.name === "Add Support for Sub Tasks" ) {
  44.               console.log(series);
  45.             }
  47.             // Parse the TaskSeries' Tasks
  48.             if ( !Array.isArray(series.task) ) {
  49.               series.task = [series.task];
  50.             }
  51.             for ( let k = 0; k < series.task.length; k++ ) {
  52.               let task = series.task[k];
  53.               rtn.push(new RTMTask(user.id, list.id, series, task));
  54.             }
  55.           }
  56.         }
  57.       }
  58.     }
  60.     // Save the task indices
  61.     taskIds.save();
  63.     // Return with the callback
  64.     return callback(null, rtn);
  66.   });
  67. }
  69. /**
  70.  * API Call rtm.tasks.add
  71.  * Note: this uses RTM's 'smart add'
  72.  * @param {string} name Task Name (or smart add syntax)
  73.  * @param {{due: *, priority: *, list: *, tags: *, location: *, start: *, repeat: *, estimate: *, to: *, url: *, note: *}} props Additional task properties
  74.  * @param user RTM User
  75.  * @param callback Callback function(err)
  76.  * @private
  77.  */
  78. function add(name, props, user, callback) {
  80.   // Parse the props keys
  81.   if ( props.due ) {
  82.     name = name + " ^" + props.due;
  83.   }
  84.   if ( props.priority ) {
  85.     name = name + " !" + props.priority
  86.   }
  87.   if ( props.list ) {
  88.     name = name + " #" + props.list;
  89.   }
  90.   if ( props.tags ) {
  91.     if ( !Array.isArray(props.tags) ) {
  92.       props.tags = [props.tags];
  93.     }
  94.     for ( let i = 0; i < props.tags.length; i++ ) {
  95.       name = name + " #" + props.tags[i];
  96.     }
  97.   }
  98.   if ( props.location ) {
  99.     name = name + " @" + props.location;
  100.   }
  101.   if ( props.start ) {
  102.     name = name + " ~" + props.start;
  103.   }
  104.   if ( props.repeat ) {
  105.     name = name + " *" + props.repeat;
  106.   }
  107.   if ( props.estimate ) {
  108.     name = name + " =" + props.estimate;
  109.   }
  110.   if ( props.to ) {
  111.     name = name + " +" + props.to;
  112.   }
  113.   if ( props.url ) {
  114.     name = name + " " + props.url;
  115.   }
  116.   if ( props.note ) {
  117.     name = name + " //" + props.note;
  118.   }
  120.   // Set the request params
  121.   let params = {
  122.     timeline: user.timeline,
  123.     name: name,
  124.     parse: '1'
  125.   };
  127.   // Make the API Request
  128.   user.get('rtm.tasks.add', params, function(err) {
  129.     return callback(err);
  130.   });
  132. }
  134. /**
  135.  * API Call: rtm.tasks.complete
  136.  * @param {number} listId RTM List ID
  137.  * @param {number} taskSeriesId RTM Task Series ID
  138.  * @param {number} taskId RTM Task ID
  139.  * @param {RTMUser} user RTM User
  140.  * @param {function} callback function(err)
  141.  * @private
  142.  */
  143. function complete(listId, taskSeriesId, taskId, user, callback) {
  144.   let params = {
  145.     timeline: user.timeline,
  146.     list_id: listId,
  147.     taskseries_id: taskSeriesId,
  148.     task_id: taskId
  149.   };
  150.   user.get('rtm.tasks.complete', params, function(err) {
  151.     return callback(err);
  152.   });
  153. }
  155. /**
  156.  * API Call: rtm.tasks.uncomplete
  157.  * @param {number} listId RTM List ID
  158.  * @param {number} taskSeriesId RTM Task Series ID
  159.  * @param {number} taskId RTM Task ID
  160.  * @param {RTMUser} user RTM User
  161.  * @param {function} callback function(err)
  162.  * @private
  163.  */
  164. function uncomplete(listId, taskSeriesId, taskId, user, callback) {
  165.   let params = {
  166.     timeline: user.timeline,
  167.     list_id: listId,
  168.     taskseries_id: taskSeriesId,
  169.     task_id: taskId
  170.   };
  171.   user.get('rtm.tasks.uncomplete', params, function(err) {
  172.     return callback(err);
  173.   });
  174. }
  176. /**
  177.  * API Call: rtm.tasks.setPriority
  178.  * @param {number} listId RTM List ID
  179.  * @param {number} taskSeriesId RTM Task Series ID
  180.  * @param {number} taskId RTM Task ID
  181.  * @param {int} priority Task Priority
  182.  * @param {RTMUser} user RTM User
  183.  * @param {function} callback function(err)
  184.  * @private
  185.  */
  186. function priority(listId, taskSeriesId, taskId, priority, user, callback) {
  187.   let params = {
  188.     timeline: user.timeline,
  189.     list_id: listId,
  190.     taskseries_id: taskSeriesId,
  191.     task_id: taskId,
  192.     priority: priority
  193.   };
  194.   user.get('rtm.tasks.setPriority', params, function(err) {
  195.     return callback(err);
  196.   });
  197. }
  199. /**
  200.  * API Call: rtm.tasks.addTags
  201.  * @param {number} listId RTM List ID
  202.  * @param {number} taskSeriesId RTM Task Series ID
  203.  * @param {number} taskId RTM Task ID
  204.  * @param {string[]} tags Tags to Add
  205.  * @param {RTMUser} user RTM User
  206.  * @param {function} callback function(err)
  207.  * @private
  208.  */
  209. function addTags(listId, taskSeriesId, taskId, tags, user, callback) {
  210.   let params = {
  211.     timeline: user.timeline,
  212.     list_id: listId,
  213.     taskseries_id: taskSeriesId,
  214.     task_id: taskId,
  215.     tags: tags.join(',')
  216.   };
  217.   user.get('rtm.tasks.addTags', params, function(err) {
  218.     return callback(err);
  219.   });
  220. }
  222. /**
  223.  * API Call: rtm.tasks.notes.add
  224.  * @param {number} listId RTM List ID
  225.  * @param {number} taskSeriesId RTM Task Series ID
  226.  * @param {number} taskId RTM Task ID
  227.  * @param {string} title Title of Note
  228.  * @param {string|string[]} notes Note(s) to add to the Task
  229.  * @param {RTMUser} user RTM User
  230.  * @param {function} callback function(err)
  231.  * @private
  232.  */
  233. function addNotes(listId, taskSeriesId, taskId, title, notes, user, callback) {
  234.   let params = {
  235.     timeline: user.timeline,
  236.     list_id: listId,
  237.     taskseries_id: taskSeriesId,
  238.     task_id: taskId,
  239. 	note_title: title,
  240.     note_text: notes
  241.   };
  242.   user.get('rtm.tasks.notes.add', params, function(err) {
  243.     return callback(err);
  244.   });
  245. }
  247. /**
  248.  * API Call: rtm.tasks.delete
  249.  * @param {number} listId RTM List ID
  250.  * @param {number} taskSeriesId RTM Task Series ID
  251.  * @param {number} taskId RTM Task ID
  252.  * @param {RTMUser} user RTM User
  253.  * @param {function} callback function(err)
  254.  * @private
  255.  */
  256. function remove(listId, taskSeriesId, taskId, user, callback) {
  257.   let params = {
  258.     timeline: user.timeline,
  259.     list_id: listId,
  260.     taskseries_id: taskSeriesId,
  261.     task_id: taskId,
  262.   };
  263.   user.get('rtm.tasks.delete', params, function(err) {
  264.     return callback(err);
  265.   });
  266. }
  268. /**
  269.  * API Call: rtm.tasks.movePriority
  270.  * @param {number} listId RTM List ID
  271.  * @param {number} taskSeriesId RTM Task Series ID
  272.  * @param {number} taskId RTM Task ID
  273.  * @param {string} direction Direction to move 'up' or 'down'
  274.  * @param {RTMUser} user RTM User
  275.  * @param {function} callback function(err)
  276.  * @private
  277.  */
  278. function movePriority(listId, taskSeriesId, taskId, direction, user, callback) {
  279.   if ( direction.toLowerCase() !== 'up' && direction.toLowerCase() !== 'down' ) {
  280.     throw "Incorrect priority direction.  Must be either 'up' or 'down'";
  281.   }
  282.   let params = {
  283.     timeline: user.timeline,
  284.     list_id: listId,
  285.     taskseries_id: taskSeriesId,
  286.     task_id: taskId,
  287.     direction: direction.toLowerCase()
  288.   };
  289.   user.get('rtm.tasks.movePriority', params, function(err) {
  290.     return callback(err);
  291.   });
  292. }
  294. /**
  295.  * API Call: rtm.tasks.moveTo
  296.  * @param {number} listId RTM List ID (original)
  297.  * @param {number} taskSeriesId RTM Task Series ID
  298.  * @param {number} taskId RTM Task ID
  299.  * @param {number} toListId RTM List ID (new)
  300.  * @param {RTMUser} user RTM User
  301.  * @param {function} callback function(err)
  302.  * @private
  303.  */
  304. function move(listId, taskSeriesId, taskId, toListId, user, callback) {
  305.   let params = {
  306.     timeline: user.timeline,
  307.     from_list_id: listId,
  308.     taskseries_id: taskSeriesId,
  309.     task_id: taskId,
  310.     to_list_id: toListId
  311.   };
  312.   user.get('rtm.tasks.moveTo', params, function(err) {
  313.     return callback(err);
  314.   });
  315. }
  317. /**
  318.  * API Call: rtm.tasks.postpone
  319.  * @param {number} listId RTM List ID
  320.  * @param {number} taskSeriesId RTM Task Series ID
  321.  * @param {number} taskId RTM Task ID
  322.  * @param {RTMUser} user RTM User
  323.  * @param {function} callback function(err)
  324.  * @private
  325.  */
  326. function postpone(listId, taskSeriesId, taskId, user, callback) {
  327.   let params = {
  328.     timeline: user.timeline,
  329.     list_id: listId,
  330.     taskseries_id: taskSeriesId,
  331.     task_id: taskId
  332.   };
  333.   user.get('rtm.tasks.postpone', params, function(err) {
  334.     return callback(err);
  335.   });
  336. }
  338. /**
  339.  * API Call: rtm.tasks.removeTags
  340.  * @param {number} listId RTM List ID
  341.  * @param {number} taskSeriesId RTM Task Series ID
  342.  * @param {number} taskId RTM Task ID
  343.  * @param {string[]} tags Tags to Remove
  344.  * @param {RTMUser} user RTM User
  345.  * @param {function} callback function(err)
  346.  * @private
  347.  */
  348. function removeTags(listId, taskSeriesId, taskId, tags, user, callback) {
  349.   let params = {
  350.     timeline: user.timeline,
  351.     list_id: listId,
  352.     taskseries_id: taskSeriesId,
  353.     task_id: taskId,
  354.     tags: tags.join(',')
  355.   };
  356.   user.get('rtm.tasks.removeTags', params, function(err) {
  357.     return callback(err);
  358.   });
  359. }
  361. /**
  362.  * API Call: rtm.tasks.setDueDate
  363.  * @param {number} listId RTM List ID
  364.  * @param {number} taskSeriesId RTM Task Series ID
  365.  * @param {number} taskId RTM Task ID
  366.  * @param {string} due Task Due Date (will be parsed by RTM)
  367.  * @param {RTMUser} user RTM User
  368.  * @param {function} callback function(err)
  369.  * @private
  370.  */
  371. function setDueDate(listId, taskSeriesId, taskId, due, user, callback) {
  372.   let params = {
  373.     timeline: user.timeline,
  374.     list_id: listId,
  375.     taskseries_id: taskSeriesId,
  376.     task_id: taskId,
  377.     due: due,
  378.     parse: 1
  379.   };
  380.   user.get('rtm.tasks.setDueDate', params, function(err) {
  381.     return callback(err);
  382.   });
  383. }
  385. /**
  386.  * API Call: rtm.tasks.setStartDate
  387.  * @param {number}   listId       RTM List ID
  388.  * @param {number}   taskSeriesId RTM Task Series ID
  389.  * @param {number}   taskId       RTM Task ID
  390.  * @param {string}   start        Task Start Date/Time (will be parsed by RTM)
  391.  * @param {RTMUser}  user         RTM User
  392.  * @param {Function} callback     Callback function(err)
  393.  */
  394. function setStartDate(listId, taskSeriesId, taskId, start, user, callback) {
  395.   let params = {
  396.     timeline: user.timeline,
  397.     list_id: listId,
  398.     taskseries_id: taskSeriesId,
  399.     task_id: taskId,
  400.     start: start,
  401.     parse: 1
  402.   };
  403.   user.get('rtm.tasks.setStartDate', params, function(err) {
  404.     return callback(err);
  405.   });
  406. }
  408. /**
  409.  * API Call: rtm.tasks.setName
  410.  * @param {number} listId RTM List ID
  411.  * @param {number} taskSeriesId RTM Task Series ID
  412.  * @param {number} taskId RTM Task ID
  413.  * @param {string} name New Task Name
  414.  * @param {RTMUser} user RTM User
  415.  * @param {function} callback function(err)
  416.  * @private
  417.  */
  418. function setName(listId, taskSeriesId, taskId, name, user, callback) {
  419.   let params = {
  420.     timeline: user.timeline,
  421.     list_id: listId,
  422.     taskseries_id: taskSeriesId,
  423.     task_id: taskId,
  424.     name: name
  425.   };
  426.   user.get('rtm.tasks.setName', params, function(err) {
  427.     return callback(err);
  428.   });
  429. }
  431. /**
  432.  * API Call: rtm.tasks.setURL
  433.  * @param {number} listId RTM List ID
  434.  * @param {number} taskSeriesId RTM Task Series ID
  435.  * @param {number} taskId RTM Task ID
  436.  * @param {string} url New Task URL
  437.  * @param {RTMUser} user RTM User
  438.  * @param {function} callback function(err)
  439.  * @private
  440.  */
  441. function setURL(listId, taskSeriesId, taskId, url, user, callback) {
  442.   let params = {
  443.     timeline: user.timeline,
  444.     list_id: listId,
  445.     taskseries_id: taskSeriesId,
  446.     task_id: taskId,
  447.     url: url
  448.   };
  449.   user.get('rtm.tasks.setURL', params, function(err) {
  450.     return callback(err);
  451.   });
  452. }
  455. module.exports = {
  456.   get: get,
  457.   add: add,
  458.   complete: complete,
  459.   uncomplete: uncomplete,
  460.   priority: priority,
  461.   addNotes: addNotes,
  462.   addTags: addTags,
  463.   remove: remove,
  464.   movePriority: movePriority,
  465.   move: move,
  466.   postpone: postpone,
  467.   removeTags: removeTags,
  468.   setDueDate: setDueDate,
  469.   setStartDate: setStartDate,
  470.   setName: setName,
  471.   setURL: setURL
  472. };