├── .editorconfig
├── .eslintrc.js
├── .gitignore
├── LICENSE.md
├── README.md
├── bin
    ├── jira.js
    └── tests.sh
├── gulpfile.js
├── lib
    ├── auth.js
    ├── ca.js
    ├── common.js
    ├── config.js
    ├── initial_config.js
    ├── jira
    │   ├── addToSprint.js
    │   ├── assign.js
    │   ├── comment.js
    │   ├── create.js
    │   ├── describe.js
    │   ├── edit.js
    │   ├── fix.js
    │   ├── link.js
    │   ├── ls.js
    │   ├── new.js
    │   ├── release.js
    │   ├── send.js
    │   ├── sprint.js
    │   ├── transitions.js
    │   ├── watch.js
    │   └── worklog.js
    ├── prompt.js
    ├── settings.js
    ├── ssl_request.js
    └── utils.js
├── package-lock.json
├── package.json
└── test
    └── unit
        └── utils
            ├── file-api.spec.js
            └── format-api.spec.js


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | end_of_line = lf
 6 | indent_size = 2
 7 | indent_style = space
 8 | insert_final_newline = true
 9 | max_line_length = 120
10 | tab_width = 2
11 | trim_trailing_whitespace = true
12 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   env: {
 3 |     es6: true,
 4 |     node: true,
 5 |   },
 6 |   globals: {},
 7 |   rules: {
 8 |     semi: ['error', 'always'],
 9 |     'no-cond-assign': ['error', 'except-parens'],
10 |     camelcase: 'error',
11 |     curly: 'off',
12 |     eqeqeq: 'error',
13 |     'no-eq-null': 'error',
14 |     'no-eval': 'off',
15 |     'wrap-iife': 'off',
16 |     indent: [
17 |       'error',
18 |       2,
19 |       {
20 |         SwitchCase: 1,
21 |       },
22 |     ],
23 |     'no-use-before-define': 'off',
24 |     'linebreak-style': ['error', 'unix'],
25 |     'comma-style': ['error', 'last'],
26 |     complexity: ['error', 15],
27 |     'max-depth': ['error', 4],
28 |     'max-statements': ['error', 25],
29 |     'new-cap': 'error',
30 |     'no-empty': [
31 |       'error',
32 |       {
33 |         allowEmptyCatch: true,
34 |       },
35 |     ],
36 |     'no-new': 'off',
37 |     quotes: ['error', 'single'],
38 |     strict: 'off',
39 |     'no-undef': 'error',
40 |     'no-unused-vars': 'error',
41 |     'eol-last': 'error',
42 |     'key-spacing': [
43 |       'error',
44 |       {
45 |         beforeColon: false,
46 |         afterColon: true,
47 |       },
48 |     ],
49 |     'no-trailing-spaces': 'error',
50 |     'space-infix-ops': 'error',
51 |     'keyword-spacing': ['error', {}],
52 |     'space-unary-ops': [
53 |       'error',
54 |       {
55 |         words: false,
56 |         nonwords: false,
57 |       },
58 |     ],
59 |     'brace-style': [
60 |       'error',
61 |       '1tbs',
62 |       {
63 |         allowSingleLine: true,
64 |       },
65 |     ],
66 |   },
67 |   'overrides': [
68 |     {
69 |       'files': [
70 |         '**/*.spec.js',
71 |         '**/*.spec.jsx'
72 |       ],
73 |       'env': {
74 |         'jest': true
75 |       }
76 |     }
77 |   ]
78 | 
79 | }
80 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | .DS_Store
3 | .jira-cmd
4 | .jira-cli
5 | .**.swp
6 | .idea
7 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Dan Shumaker
 4 | Copyright (c) 2017 Germán Robledo
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | jira-cli
 2 | ========
 3 | 
 4 | [![NPM Version](https://badge.fury.io/js/jira-cli.svg)](https://npmjs.org/package/jira-cli)
 5 | [![Package downloads](http://img.shields.io/npm/dm/jira-cli.svg)](https://npmjs.org/package/jira-cli)
 6 | [Jira API Reference](https://docs.atlassian.com/software/jira/docs/api/REST/8.1.0/)
 7 | 
 8 | A Jira command line interface (forked from https://github.com/germanrcuriel/jira-cmd )
 9 | 
10 | ## Deprecation Notice / Maintenance Transfer to Fork
11 | 
12 | - This repo is deprecated and no longer maintained.
13 | 
14 | - Please see https://github.com/palashkulsh/jira-cmd for all future requests and features.
15 | 
16 | - Sincere thanks to Palash and all those who contributed to this fork while it lasted.
17 | 


--------------------------------------------------------------------------------
/bin/jira.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | //
  3 | // Main API       : https://docs.atlassian.com/software/jira/docs/api/REST/8.1.0/
  4 | // Creating Issues: https://developer.atlassian.com/jiradev/jira-apis/about-the-jira-rest-apis/jira-rest-api-tutorials/jira-rest-api-examples#JIRARESTAPIexamples-Creatinganissueusingcustomfields
  5 | // Issue Links    : https://docs.atlassian.com/jira/REST/server/?_ga=2.55654315.1871534859.1501779326-1034760119.1468908320#api/2/issueLink-linkIssues
  6 | // Required Fields: https://jira.mypaytm.com/rest/api/2/issue/createmeta?projectKeys=MDO&expand=projects.issuetypes.fields&
  7 | // Meta-data      : http://localhost:8080/rest/api/2/issue/JRA-13/editmeta
  8 | //
  9 | 
 10 | var program = require('commander');
 11 | var config = require('../lib/config');
 12 | var auth = require('../lib/auth');
 13 | var ls = require('../lib/jira/ls');
 14 | var describe = require('../lib/jira/describe');
 15 | var assign = require('../lib/jira/assign');
 16 | var fix = require('../lib/jira/fix');
 17 | var release = require('../lib/jira/release');
 18 | var send = require('../lib/jira/send');
 19 | var comment = require('../lib/jira/comment');
 20 | var sprint = require('../lib/jira/sprint');
 21 | var transitions = require('../lib/jira/transitions');
 22 | var worklog = require('../lib/jira/worklog');
 23 | var link = require('../lib/jira/link');
 24 | var watch = require('../lib/jira/watch');
 25 | var addToSprint = require('../lib/jira/addToSprint');
 26 | var newCreate = require('../lib/jira/new');
 27 | var _set = require('lodash.set');
 28 | 
 29 | var edit = require('../lib/jira/edit');
 30 | 
 31 | const pkg = require('../package.json');
 32 | const CreateIssue = require('../lib/jira/create');
 33 | const JiraClient = require('jira-connector');
 34 | 
 35 | function finalCb(err) {
 36 |   if (err) {
 37 |     console.log(err.toString());
 38 |   }
 39 | 
 40 |   process.exit(1);
 41 | }
 42 | 
 43 | // this code will ensure that in the event we're putting a large response to stdout (large json response for example)
 44 | //   that the process does not shutdown before stdout has finished processing the response
 45 | // https://github.com/pnp/cli-microsoft365/issues/1266
 46 | if (process.stdout._handle) {
 47 |   process.stdout._handle.setBlocking(true);
 48 | }
 49 | 
 50 | program.version(pkg.version);
 51 | program
 52 |   .command('ls')
 53 |   .description('List my issues')
 54 |   .option('-p, --project <name>', 'Filter by project', String)
 55 |   .option('-t, --type <name>', 'Filter by type', String)
 56 |   .option('-v, --verbose', 'verbose output')
 57 |   .action(function(options) {
 58 |     if (options.project) {
 59 |       ls.showByProject(options, finalCb);
 60 |     } else {
 61 |       ls.showAll(options, finalCb);
 62 |     }
 63 |   });
 64 | program
 65 |   .command('start <issue>')
 66 |   .description('Start working on an issue.')
 67 |   .action(function(issue) {
 68 |     transitions.start(issue, finalCb);
 69 |   });
 70 | program
 71 |   .command('stop <issue>')
 72 |   .description('Stop working on an issue.')
 73 |   .action(function(issue) {
 74 |     transitions.stop(issue, finalCb);
 75 |   });
 76 | program
 77 |   .command('review <issue> [assignee]')
 78 |   .description('Mark issue as being reviewed [by assignee(optional)].')
 79 |   .action(function(issue, assignee) {
 80 |     transitions.review(issue, finalCb);
 81 | 
 82 |     if (assignee) {
 83 |       assign.to(issue, assignee, finalCb);
 84 |     }
 85 |   });
 86 | program
 87 |   .command('done <issue>')
 88 |   .option('-r, --resolution <name>', 'resolution name (e.g. \'Resolved\')', String)
 89 |   .option('-t, --timeSpent <time>', 'how much time spent (e.g. \'3h 30m\')', String)
 90 |   .description('Mark issue as finished.')
 91 |   .action(function(issue, options) {
 92 |     if (options.timeSpent) {
 93 |       worklog.add(issue, options.timeSpent, 'auto worklog', new Date(), finalCb);
 94 |     }
 95 | 
 96 |     transitions.done(issue, options.resolution, finalCb);
 97 |   });
 98 | program
 99 |   .command('invalid <issue>')
100 |   .description('Mark issue as finished.')
101 |   .action(function(issue,options) {
102 |     transitions.invalid(issue, options, finalCb);
103 |   });
104 | program
105 |   .command('mark <issue> [transitionId]')
106 |   .description('Mark issue as.')
107 |   .action(function(issue, transitionId) {
108 |     if (transitionId) { // if a transitionId is provided, go straight to transitioning the story
109 |       transitions.doTransition(issue, transitionId, function (err) {
110 |         if (err && err.includes('(502)')) { // if we get a 502 it's most likely because the transition isn't valid
111 |           console.log('transition (' +  transitionId + ') not valid for this issue (' + issue + ')');
112 |         } else {
113 |           console.log('marked issue with transition ' + transitionId);
114 |         }
115 |         finalCb(err);
116 |       });
117 |     } else {
118 |       transitions.makeTransition(issue, finalCb);
119 |     }
120 |   });
121 | program
122 |   .command('edit <issue> [input]')
123 |   .description('edit issue.')
124 |   .action(function(issue, input) {
125 |     if (input) {
126 |       edit.editWithInputPutBody(issue, input, finalCb);
127 |     } else {
128 |       edit.edit(issue, finalCb);
129 |     }
130 |   });
131 | program
132 |   .command('running')
133 |   .description('List issues in progress.')
134 |   .action(function() {
135 |     ls.showInProgress(finalCb);
136 |   });
137 | program
138 |   .command('jql <query>')
139 |   .description('Run JQL query')
140 |   .option('-c, --custom <name>', 'Filter by custom jql saved in jira config', String)
141 |   .option('-s, --custom_sql <name>', 'Filter by custom alasql saved in jira config', String)
142 |   .option('-j, --json <value>', 'Output in json', String, 0)
143 |   .option('-v, --verbose', 'verbose output')
144 |   .action(function(query, options) {
145 |     if (options.custom_sql) {
146 |       ls.aggregateResults(query, options, finalCb);
147 |     } else if (options.json) {
148 |       ls.jqlSearch(query, options, (err, issues) => {
149 |         if (issues) {
150 |           console.log(JSON.stringify(issues));
151 |         }
152 |         finalCb(err);
153 |       });
154 |     } else {
155 |       ls.jqlSearch(query, options, finalCb);
156 |     }
157 |   });
158 | program
159 |   .command('link <from> <to> [linkValue]')
160 |   .description('link issues')
161 |   .action(function(from, to, linkValue, options) {
162 |     link(from, to, linkValue, options, finalCb);
163 |   });
164 | program
165 |   .command('search <term>')
166 |   .description('Find issues.')
167 |   .action(function(query) {
168 |     ls.search(query, finalCb);
169 |   });
170 | program
171 |   .command('assign <issue> [accountId]')
172 |   .description(
173 |     'Assign an issue to <user>. Provide only issue# to assign to me.\n' +
174 |     'Use config (assign.unassignText) to choose what value to use to unassign an issue (default: \'null\').'
175 |   )
176 |   .action(function(issue, user) {
177 |     if (user) {
178 |       user = config.user_alias[user] || user;
179 |       assign.to(issue, user, finalCb);
180 |     } else {
181 |       assign.me(issue, finalCb);
182 |     }
183 |   });
184 | program
185 |   .command('watch <issue> [user]')
186 |   .description('Watch an issue to <user>. Provide only issue# to watch to me')
187 |   .action(function(issue, user) {
188 |     if (user) {
189 |       user = config.user_alias[user];
190 |       watch.to(issue, user, finalCb);
191 |     } else {
192 |       watch.me(issue, finalCb);
193 |     }
194 |   });
195 | program
196 |   .command('comment <issue> [text]')
197 |   .description('Comment an issue.')
198 |   .action(function(issue, text) {
199 |     if (text) {
200 |       //replace name in comment text if present in user_alias config
201 |       //if vikas is nickname stored in user_alias config for vikas.sharma
202 |       //then 'vikas has username [~vikas] [~ajitk] [~mohit] becomes 'vikas has username [~vikas.sharma] [~ajitk] [~mohit]
203 |       //names which do not match any alias are not changed
204 |       text = text.replace(/\[~(.*?)\]/g, function(match, tag, index) {
205 |         if (config.user_alias[tag]) {
206 |           return '[~' + config.user_alias[tag] + ']';
207 |         } else {
208 |           return tag;
209 |         }
210 |       });
211 |       comment.to(issue, text, finalCb);
212 |     } else {
213 |       comment.show(issue, finalCb);
214 |     }
215 |   });
216 | program
217 |   .command('show <issue>')
218 |   .description('Show info about an issue')
219 |   .option('-o, --output <field>', 'Output field content', String)
220 |   .action(function(issue, options) {
221 |     if (options.output) {
222 |       describe.show(issue, options.output, finalCb);
223 |     } else {
224 |       describe.show(issue, null, finalCb);
225 |     }
226 |   });
227 | program
228 |   .command('open <issue>')
229 |   .description('Open an issue in a browser')
230 |   .action(function(issue, options) {
231 |     describe.open(issue);
232 |   });
233 | program
234 |   .command('worklog <issue>')
235 |   .description('Show worklog about an issue')
236 |   .action(function(issue) {
237 |     worklog.show(issue, finalCb);
238 |   });
239 | program
240 |   .command('worklogadd <issue> <timeSpent> [comment]')
241 |   .description('Log work for an issue')
242 |   .option('-s, --startedAt [value]', 'Set date of work (default is now)')
243 |   .action(function(issue, timeSpent, comment, p) {
244 |     var o = p.startedAt || new Date().toString(),
245 |       s = new Date(o);
246 |     worklog.add(issue, timeSpent, comment, s, finalCb);
247 |   })
248 |   .on('--help', function() {
249 |     console.log('  Worklog Add Help:');
250 |     console.log();
251 |     console.log('    <issue>: JIRA issue to log work for');
252 |     console.log('    <timeSpent>: how much time spent (e.g. \'3h 30m\')');
253 |     console.log('    <comment> (optional) comment');
254 |     console.log();
255 |   });
256 | program
257 |   .command('create [project[-issue]]')
258 |   .description('Create an issue or a sub-task')
259 |   .option('-p, --project <project>', 'Rapid board on which project is to be created', String)
260 |   .option('-P, --priority <priority>', 'priority of the issue', String)
261 |   .option('-T --type <type>', 'NUMERIC Issue type', parseInt)
262 |   .option('-s --subtask <subtask>', 'Issue subtask', String)
263 |   .option('-S --summary <summary>', 'Issue Summary', String)
264 |   .option('-d --description <description>', 'Issue description', String)
265 |   .option('-a --assignee <assignee>', 'Issue assignee', String)
266 |   .option('-v --verbose', 'Verbose debugging output')
267 |   .action(function(project, options) {
268 |     if (config && config.authNew) {
269 |       const jira = new JiraClient({
270 |         host: config.authNew.host,
271 |         // eslint-disable-next-line camelcase
272 |         basic_auth: {
273 |           base64: config.authNew.token
274 |         }
275 |       });
276 |       const _create = new CreateIssue(jira);
277 |       _create.newIssue(project, options);
278 |     }
279 |   });
280 | program
281 |   .command('new [key]')
282 |   .description('Create an issue or a sub-task')
283 |   .option('-p, --project <project>', 'Rapid board on which project is to be created', String)
284 |   .option('-P, --priority <priority>', 'priority of the issue', String)
285 |   .option('-T --type <type>', 'Issue type', String)
286 |   .option('-s --subtask <subtask>', 'Issue subtask', String)
287 |   .option('-S --summary <summary>', 'Issue summary', String)
288 |   .option('-d --description <description>', 'Issue description', String)
289 |   .option('-c --component <component>', 'Issue component', String)
290 |   .option('-l --label <label>', 'Issue label', String)
291 |   .option('-a --assignee <assignee>', 'Issue assignee', String)
292 |   .option(
293 |     '-f, --field <fields...>',
294 |     'Define custom fields from the command line in key=value pairs',
295 |     (value, previous) => {
296 |       let values = {...previous};
297 |       if(!values) {
298 |         values = {};
299 |       }
300 |       // we can accept , separated notation or multi argument 
301 |       // i.e. -f "parent.id=156199" -f "issueType.id=10101" or -f "parent.id=156199, issueType.id=10101"
302 |       for(const fields of value.split(',')) {
303 |         // get a single key=value pair
304 |         const fieldName = fields.split('=')[0];
305 |         let fieldValue = fields.split('=')[1];
306 | 
307 |         if (parseInt(fieldValue)) {
308 |           // if it's an integer let's treat it as such
309 |           fieldValue = parseInt(fieldValue);
310 |         } else {
311 |           // trim any strings so jira matches them properly
312 |           fieldValue = fieldValue.trim();
313 |           // powershell is weird about strings so sometimes it will result in fieldValue = ''string''
314 |           if(fieldValue.includes('\'')){
315 |             fieldValue = fieldValue.replaceAll('\'', '');
316 |           }
317 |         }
318 |         if(fieldName && fieldValue) {
319 |           if (fieldName.includes('.')) {
320 |             // if we've used dot notation let's create the full object path
321 |             _set(values, fieldName, fieldValue);
322 |           } else {
323 |             values[fieldName.trim()] = fieldValue;
324 |           }
325 |         }
326 |       }
327 |       return values;
328 |     }
329 |   )
330 |   .option('-v --verbose', 'Verbose debugging output')
331 |   .action(function(key, options) {
332 |     options.key = key;
333 |     newCreate.create(options, finalCb);
334 |   });
335 | program
336 |   .command('config')
337 |   .description('Change configuration')
338 |   .option('-c, --clear', 'Clear stored configuration')
339 |   .option('-u, --url', 'Print url in config')
340 |   .option('-t, --template <template>', 'Start config with this given template', String)
341 |   .option('-v, --verbose', 'verbose debugging output')
342 |   .action(function(options) {
343 |     if (options.clear) {
344 |       auth.clearConfig();
345 |     } else {
346 |       if (options.url) {
347 |         console.log(config.auth.url);
348 |       } else {
349 |         auth.setup(options);
350 |       }
351 |     }
352 |   })
353 |   .on('--help', function() {
354 |     console.log('  Config Help:');
355 |     console.log();
356 |     console.log('    Jira URL: https://foo.atlassian.net/');
357 |     console.log('    Username: user (for user@foo.bar)');
358 |     console.log('    Password: Your password');
359 |     console.log('');
360 |     console.log('WARNING:After three failed login attempts Atlassian forces a CAPTCHA login');
361 |     console.log('WARNING:  which can only be done via the browser.');
362 |   });
363 | program
364 |   .command('sprint')
365 |   .description(
366 |     'Works with sprint boards\n' +
367 |       '\t\t\t\tWith no arguments, displays all rapid boards\n' +
368 |       '\t\t\t\tWith -r argument, attempt to find a single rapid board\n ' +
369 |       '\t\t\t\tand display its active sprints\n' +
370 |       '\t\t\t\tWith both -r and -s arguments\n ' +
371 |       '\t\t\t\tattempt to get a single rapidboard/ sprint and show its issues. If\n ' +
372 |       '\t\t\t\ta single sprint board isnt found, show all matching sprint boards\n'
373 |   )
374 |   .option('-r, --rapidboard <name>', 'Rapidboard to show sprints for', String)
375 |   .option('-s, --sprint <name>', 'Sprint to show the issues', String)
376 |   .option('-a, --add <projIssue> ', 'Add project issue to sprint', String)
377 |   .option('-i, --sprintId <sprintId> ', 'Id of the sprint which you want your issues to be added to', String)
378 |   .option('-j, --jql <jql> ', 'jql of the issues which you want to add to the sprint', String)
379 |   .action(function(options) {
380 |     if (options.add) {
381 |       addToSprint.addIssuesViaKey(options, finalCb);
382 |     } else if (options.jql) {
383 |       addToSprint.addAllJqlToSprint(options, finalCb);
384 |     } else {
385 |       sprint(options.rapidboard, options.sprint, finalCb);
386 |     }
387 |   });
388 | program
389 |   .command('fix <issue> <version>')
390 |   .description('Set FixVersion of an issue to <version>.')
391 |   .option('-a, --append', 'Append fix instead of over-write')
392 |   .action(function(issue, version, options) {
393 |     if (options.append) {
394 |       fix.append(issue, version, finalCb);
395 |     } else {
396 |       fix.to(issue, version, finalCb);
397 |     }
398 |   });
399 | program
400 |   .command('release <version>')
401 |   .description('Create a FixVersion/Release (see release -h for more details)')
402 |   .option('-p, --project <name>', 'Project', String)
403 |   .option('-d, --description <name>', 'Description', String)
404 |   .option('-r, --released', 'Set released to true - default is false')
405 |   .action(function(version, options) {
406 |     release.create(version, options, finalCb);
407 |   });
408 | program
409 |   .command('send')
410 |   .description('Send email report (see send -h for more details)')
411 |   .option('-i, --projectId <id>', 'Project ID', String)
412 |   .option('-p, --project_prefix <XX>', 'Project Prefix', String)
413 |   .option('-v, --version <number>', 'Version ID Number', String)
414 |   .option('-n, --name <name>', 'release name', String)
415 |   .option('-f, --from <name>', 'from name', String)
416 |   .option('-t, --to <name>', 'comma seperated email list', String)
417 |   .option('-c, --cc <name>', 'comma seperated email list', String)
418 |   .option('-s, --subject <name>', 'email subject', String)
419 |   .option('-x, --password <password>', 'email password', String)
420 |   .option('-e, --template <file>', 'email template', String)
421 |   .action(function(options) {
422 |     send.send(options);
423 |   });
424 | program.parse(process.argv);
425 | 
426 | if (program.args.length === 0) {
427 |   console.log('\nYour first step is to run the config option.\n');
428 |   program.help();
429 | }
430 | 


--------------------------------------------------------------------------------
/bin/tests.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash -xv
 2 | 
 3 | # Test Examples
 4 | # NOTE: the send command requires a manual edit of this file to work - Change the -x password
 5 | 
 6 | j='bin/jira.js'
 7 | $j -h
 8 | $j config -c
 9 | $j config -t ~/.jira-cmd-config-default.json
10 | $j ls
11 | $j create -v -p MTIE -T 1 -S "Test issue" -d "test description"
12 | $j new MTIE -S "Testing from jira-cli"
13 | $j release -p MTIE -d "Test release unreleased" 2.9.9
14 | $j release -p MTIE -d "Test release released" 3.0.0 -r
15 | $j jql "assignee = dshumaker and status not in (\"Closed\", \"Ready for Client\") and sprint in openSprints()"
16 | $j jql 'key in ( "MTIE-1102","MTIE-1508","MTIE-1530","MTIE-1545","MTIE-1566","MTIE-1584","MTIE-1617" ) ORDER BY Key'
17 | $j jql 'project = "MTI: E-Commerce" AND Status = "In Test" AND (fixVersion is EMPTY OR fixVersion not in releasedVersions()) ORDER BY Rank'
18 | 
19 | # This test must be last because of the lame Control-C mandate -- TODO fix this
20 | $j send -i 12306 -p MTIE -v 14140 -n 2.2.5 -t dshumaker@phase2technology.com -s 'MTIE Code Release to AWS servers 2.2.5' -f 'Dan Shumaker' -e /Users/dan/work/Phase2/mti/mti_cms/admin/release_template.html -x you-need-to-change-this-to-your-gmail-password
21 | 


--------------------------------------------------------------------------------
/gulpfile.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | var gulpfile = require('gulp');
 4 | var babel = require('gulp-babel');
 5 | 
 6 | gulpfile.task('copy_src', function () {
 7 |   return gulpfile.src(['lib/**/*.js'], { base: '.' })
 8 |     .pipe(gulpfile.dest('build'));
 9 | });
10 | gulpfile.task('copy_bin', function () {
11 |   return gulpfile.src(['bin/**/*.js'], { base: '.' })
12 |     .pipe(gulpfile.dest('build'));
13 | });
14 | 
15 | gulpfile.task('compile-es6-src', function () {
16 |   return gulpfile.src('lib/**/*.js')
17 |     .pipe(babel({'plugins': ['babel-plugin-transform-amd-to-commonjs']}))
18 |     .pipe(gulpfile.dest('build/js/lib'));
19 | });
20 | gulpfile.task('compile-es6-bin', function () {
21 |   return gulpfile.src('bin/**/*.js')
22 |     .pipe(babel({'plugins': ['babel-plugin-transform-amd-to-commonjs']}))
23 |     .pipe(gulpfile.dest('build/js/bin'));
24 | });
25 | 
26 | gulpfile.task('default', gulpfile.series(['compile-es6-src', 'compile-es6-bin']));
27 | 


--------------------------------------------------------------------------------
/lib/auth.js:
--------------------------------------------------------------------------------
  1 | /*global requirejs,define,fs*/
  2 | module.exports = function () {
  3 |   const promptly = require('promptly');
  4 | 
  5 |   var fs = require('fs');
  6 | 
  7 |   var path = require('path');
  8 | 
  9 |   var config = require('./config');
 10 | 
 11 |   const auth = {
 12 |     answers: {},
 13 |     ask: function (question, callback, password) {
 14 |       var that = this;
 15 | 
 16 |       if (password) {
 17 |         promptly
 18 |           .password(question)
 19 |           .then(answer => {
 20 |             if (answer.length > 0) {
 21 |               callback(answer);
 22 |             } else {
 23 |               that.ask(question, callback, true);
 24 |             }
 25 |           })
 26 |           .catch(e => {
 27 |             if(e && e.message === 'canceled') {
 28 |               console.log('\nInput cancelled');
 29 |             } else {
 30 |               console.log('\nError: ' + e.toString());
 31 |             }
 32 |           });
 33 |       } else {
 34 |         promptly
 35 |           .prompt(question)
 36 |           .then(answer => {
 37 |             if (answer.length > 0) {
 38 |               callback(answer);
 39 |             } else {
 40 |               that.ask(question, callback);
 41 |             }
 42 |           })
 43 |           .catch(e => {
 44 |             if(e && e.message === 'canceled') {
 45 |               console.log('\nInput cancelled');
 46 |             } else {
 47 |               console.log('\nError: ' + e.toString());
 48 |             }
 49 |           });
 50 |       }
 51 |     },
 52 |     setup: function (options) {
 53 |       var that = this; // Does your config file exist
 54 | 
 55 |       if (!config.isLoaded()) {
 56 |         // If not then create it
 57 |         this.ask('Jira URL: ', function (answer) {
 58 |           that.answers.url = answer;
 59 |           that.ask('Username: ', function (answer) {
 60 |             that.answers.user = answer;
 61 |             that.ask('Password: ', function (answer) {
 62 |               that.answers.pass = answer;
 63 |               process.stdin.destroy();
 64 |               that.saveConfig(options);
 65 |             }, true);
 66 |           });
 67 |         });
 68 |       }
 69 |     },
 70 |     clearConfig: function () {
 71 |       promptly
 72 |         .prompt('Are you sure? ')
 73 |         .then(answer => {
 74 |           if (answer) {
 75 |             config.clear();
 76 |             console.log('Configuration deleted successfully!');
 77 |           }
 78 |   
 79 |           process.stdin.destroy();
 80 |         })
 81 |         .catch(e => {
 82 |           if(e && e.message === 'canceled') {
 83 |             console.log('\nInput cancelled');
 84 |           } else {
 85 |             console.log('\nError: ' + e.toString());
 86 |           }
 87 |         });
 88 |     },
 89 |     saveConfig: function (options) {
 90 |       if (this.answers.url) {
 91 |         if (!/\/$/.test(this.answers.url)) {
 92 |           this.answers.url += '/';
 93 |         }
 94 |       }
 95 | 
 96 |       if (this.answers.user && this.answers.pass) {
 97 |         this.answers.token = this.answers.user + ':' + this.answers.pass;
 98 |         const auth = {
 99 |           url: this.answers.url,
100 |           user: this.answers.user,
101 |           token: Buffer.from(this.answers.token).toString('base64')
102 |         };
103 |         delete this.answers.pass;
104 | 
105 |         if (options.verbose) {
106 |           console.log(options);
107 |         }
108 | 
109 |         if (options.template && fs.existsSync(options.template)) {
110 |           console.log('Using cli supplied default config file');
111 |           config.loadInitialFromTemplate(options.template);
112 |         }
113 | 
114 |         config.update('auth', auth);
115 |         config.save();
116 |         console.log('Information stored!');
117 |       }
118 |     }
119 |   };
120 |   return auth;
121 | }();
122 | 


--------------------------------------------------------------------------------
/lib/ca.js:
--------------------------------------------------------------------------------
1 | 
2 | module.exports = (() => {
3 |   const settings = require('./settings');
4 |   const fs = require('fs');
5 |   ca = fs.readFileSync(settings.getCertificateFilePath());
6 |   return ca;
7 | })();
8 | 


--------------------------------------------------------------------------------
/lib/common.js:
--------------------------------------------------------------------------------
 1 | module.exports = function () {
 2 |   const promptly = require('promptly');
 3 | 
 4 |   var commonUtils = {
 5 |     ask: function (question, callback, yesno, values, answer) {
 6 |       var that = this,
 7 |         issueTypes = [],
 8 |         i = 0;
 9 | 
10 |       if (answer || answer === false) {
11 |         return callback(answer);
12 |       }
13 | 
14 |       if (values && values.length > 0) {
15 |         for (i; i < values.length; i++) {
16 |           if (that.isSubTask) {
17 |             if (values[i].subtask !== undefined) {
18 |               if (values[i].subtask) {
19 |                 issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
20 |               }
21 |             } else {
22 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
23 |             }
24 |           } else {
25 |             if (!values[i].subtask) {
26 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
27 |             }
28 |           }
29 |         }
30 | 
31 |         console.log(issueTypes.join('\n'));
32 |       }
33 | 
34 |       promptly
35 |         .prompt(question)
36 |         .then(answer => {
37 |           if (answer.length > 0) {
38 |             callback(answer);
39 |           } else {
40 |             if (yesno) {
41 |               callback(false);
42 |             } else {
43 |               that.ask(question, callback);
44 |             }
45 |           }
46 |         })
47 |         .catch(e => {
48 |           if(e && e.message === 'canceled') {
49 |             console.log('\nInput cancelled');
50 |           } else {
51 |             console.log('\nError: ' + e.toString());
52 |           }
53 |         });
54 |     }
55 |   };
56 |   return commonUtils;
57 | }();
58 | 


--------------------------------------------------------------------------------
/lib/config.js:
--------------------------------------------------------------------------------
 1 | /*global path, define*/
 2 | module.exports = function () {
 3 |   var settings = require('./settings');
 4 | 
 5 |   var initialConfig = require('./initial_config');
 6 | 
 7 |   var utils = require('./utils');
 8 |   let _data = {};
 9 |   const configDir = settings.getConfigDirectory();
10 |   const configFilePath = settings.getConfigFilePath();
11 | 
12 |   _ensureConfig();
13 | 
14 |   _load();
15 | 
16 |   function _ensureConfig() {
17 |     utils.createDirectory(configDir);
18 |   }
19 | 
20 |   function _update(key, value) {
21 |     _data[key] = value;
22 |   }
23 | 
24 |   function _loadConfigFromFile(configFile, defConfig) {
25 |     if (utils.isFileExists(configFile)) {
26 |       return _createConfig(utils.loadFromFile(configFile));
27 |     }
28 | 
29 |     return defConfig;
30 |   }
31 | 
32 |   function _loadInitialFromTemplate(template) {
33 |     _data = _loadConfigFromFile(template, initialConfig);
34 |     return true;
35 |   }
36 | 
37 |   function formatToNewAuth(auth) {
38 |     const { url, token } = auth
39 |     if (url) {
40 |       let { host, pathname, protocol } = new URL(url)
41 |       pathname = pathname.endsWith('/') ? pathname.slice(0, pathname.length - 1) : pathname
42 | 
43 |       return { host: host + pathname, protocol: protocol, token: token }
44 |     }
45 |     return auth
46 |   }
47 | 
48 |   function _createConfig(configFileContent) {
49 |     let configObject = JSON.parse(configFileContent);
50 |     let config = {
51 |       auth: configObject.auth,
52 |       authNew: formatToNewAuth(configObject.auth),
53 |       options: configObject.options,
54 |       custom_jql: configObject.custom_jql,
55 |       custom_alasql: configObject.custom_alasql,
56 |       assign: configObject.assign,
57 |       user_alias: configObject.user_alias,
58 |       edit_meta: configObject.edit_meta,
59 |       default_create: configObject.default_create,
60 |       use_self_signed_certificate: configObject.use_self_signed_certificate
61 |     };
62 | 
63 |     if (!config.options || !config.options["jira_stop"]) {
64 |       console.error('Ops! Seems like your ' + configFilePath + ' is out of date. Please reset you configuration.');
65 |       return {};
66 |     }
67 | 
68 |     return config;
69 |   }
70 | 
71 |   function _load() {
72 |     _data = _loadConfigFromFile(configFilePath, initialConfig);
73 |     return _isLoaded();
74 |   }
75 | 
76 |   function _isLoaded() {
77 |     return _data.auth.url !== undefined;
78 |   }
79 | 
80 |   function _save() {
81 |     utils.saveToFile(configFilePath, JSON.stringify(_data, null, 2));
82 |   }
83 | 
84 |   function _clear() {
85 |     utils.deleteFile(configFilePath);
86 |     utils.deleteDirectory(configDir);
87 |   }
88 | 
89 |   const api = {
90 |     save: _save,
91 |     load: _load,
92 |     update: _update,
93 |     clear: _clear,
94 |     loadInitialFromTemplate: _loadInitialFromTemplate,
95 |     isLoaded: _isLoaded
96 |   }
97 |   return { ..._data, ...api };
98 | }();
99 | 


--------------------------------------------------------------------------------
/lib/initial_config.js:
--------------------------------------------------------------------------------
 1 | /*global requirejs,define,fs*/
 2 | module.exports = function () {
 3 |   return {
 4 |     auth: {},
 5 |     custom_jql: {
 6 |       reported: 'reporter=currentUser() and status not in (\'Done\')'
 7 |     },
 8 |     user_alias: {
 9 |       'NICKNAME': 'USERNAME_OF_USER'
10 |     },
11 |     'custom_alasql': {
12 |       'project': 'select fields->project->name , count(1)  AS counter from ? group by fields->project->name',
13 |       'priority': 'select fields->priority->name , count(1)  AS counter from ? group by fields->priority->name',
14 |       'status': 'select fields->project->name,fields->status->name , count(1)  AS counter from ? group by fields->project->name,fields->status->name'
15 |     },
16 |     'assign': {
17 |       'unassignText': 'null'
18 |     },
19 |     'default_create': {
20 |       '__always_ask': {
21 |         'fields': {
22 |           'description': {},
23 |           'priority': {}
24 |         }
25 |       },
26 |       'YOUR_ALIAS': {
27 |         'project': 'YOUR_PROJECT',
28 |         'issueType': 3,
29 |         'default': {
30 |           'components': [{
31 |             'id': '15226'
32 |           }],
33 |           'customfield_12901': 'infrastructure',
34 |           'customfield_12902': {
35 |             'id': '11237'
36 |           }
37 |         }
38 |       }
39 |     },
40 |     'edit_meta': {
41 |       '__default': {
42 |         'wish': {
43 |           'fields': {
44 |             'priority': {
45 |               'id': '9'
46 |             }
47 |           }
48 |         }
49 |       },
50 |       'sprint': {
51 |         'key': 'customfield_10007'
52 |       },
53 |       'label': {
54 |         'key': 'labels',
55 |         'default': {
56 |           'test1': 't1,t2'
57 |         }
58 |       }
59 |     },
60 |     options: {
61 |       jira_stop: {
62 |         status: 'To Do'
63 |       },
64 |       jira_start: {
65 |         status: 'In Progress'
66 |       },
67 |       jira_review: {
68 |         status: 'In Review'
69 |       },
70 |       'jira_invalid': {
71 |         'status': 'Invalid'
72 |       },
73 |       jira_done: {
74 |         status: 'Done',
75 |         check_resolution: false
76 |       },
77 |       available_issues_statuses: ['Open', 'In Progress', 'Reopened', 'To Do', 'In Review'],
78 |       use_self_signed_certificate: false,
79 |     }
80 |   };
81 | }();
82 | 


--------------------------------------------------------------------------------
/lib/jira/addToSprint.js:
--------------------------------------------------------------------------------
  1 | //https://jira.mypaytm.com/rest/api/2/issue/MPP-509/editmeta
  2 | //https://developer.atlassian.com/jiradev/jira-apis/jira-rest-apis/jira-rest-api-tutorials/jira-rest-api-example-edit-issues
  3 | 
  4 | /*global requirejs,console,define,fs*/
  5 | module.exports = function () {
  6 |   const promptly = require('promptly');
  7 | 
  8 |   var sslRequest = require('../../lib/ssl_request');
  9 | 
 10 |   var config = require('../../lib/config');
 11 | 
 12 |   var sprint = require('./sprint');
 13 | 
 14 |   var ls = require('./ls');
 15 | 
 16 |   var async = require('async');
 17 | 
 18 |   function ask(question, callback, yesno, values) {
 19 |     var that = this,
 20 |       issueTypes = [],
 21 |       i = 0;
 22 | 
 23 |     if (values && values.length > 0) {
 24 |       for (i; i < values.length; i++) {
 25 |         issueTypes.push('(' + values[i][0] + ') ' + values[i][1]);
 26 |       }
 27 | 
 28 |       console.log(issueTypes.join('\n'));
 29 |     }
 30 | 
 31 |     promptly
 32 |       .prompt(question)
 33 |       .then(answer => {
 34 |         if (answer.length > 0) {
 35 |           callback(answer);
 36 |         } else {
 37 |           if (yesno) {
 38 |             callback(false);
 39 |           } else {
 40 |             that.ask(question, callback);
 41 |           }
 42 |         }
 43 |       })
 44 |       .catch(e => {
 45 |         if(e && e.message === 'canceled') {
 46 |           console.log('\nInput cancelled');
 47 |         } else {
 48 |           console.log('\nError: ' + e.toString());
 49 |         }
 50 |       });
 51 |   }
 52 | 
 53 |   var addToSprint = {
 54 |     addIssuesViaKey: function addIssuesViaKey(options, cb) {
 55 |       if (options.rapidboard || options.sprint) {
 56 |         sprint(options.rapidboard, options.sprint, function (sprintData) {
 57 |           ask('Please enter the sprint', function (sprintId) {
 58 |             console.log('here');
 59 |             addToSprint(sprintId, options.add, cb);
 60 |           }, false, sprintData);
 61 |         });
 62 |       } else if (options.jql) {
 63 |         addAllJqlToSprint(options.sprintId, options.jql, cb);
 64 |       } else if (options.sprintId) {
 65 |         addToSprint(options.sprintId, options.add, cb);
 66 |       }
 67 |     },
 68 |     addAllJqlToSprint: function addAllJqlToSprint(options, cb) {
 69 |       if (!options.jql || !options.sprintId) {
 70 |         return cb(new Error('jql or sprint id not found'));
 71 |       }
 72 | 
 73 |       ls.jqlSearch(options.jql, {}, function (err, issues) {
 74 |         ask('Are you sure you want to add all above issues in sprint id ' + options.sprintId + ' [y/N]: ', function (answer) {
 75 |           if (answer !== 'y') {
 76 |             return cb('no issues were added to sprint');
 77 |           }
 78 | 
 79 |           async.eachSeries(issues, function (eachIssue, scb) {
 80 |             addToSprint(options.sprintId, eachIssue.key, scb);
 81 |           }, function () {
 82 |             return cb();
 83 |           });
 84 |         }, true);
 85 |       });
 86 |     }
 87 |   };
 88 | 
 89 |   function addAllJqlToSprint(sprintId, jql, cb) {
 90 |     ls.jqlSearch(jql, {}, function (err, issues) {
 91 |       ask('Are you sure you want to add all above issues in sprint id ' + sprintId + ':', function (answer) {
 92 |         console.log(answer);
 93 |       }, true);
 94 |     });
 95 |   }
 96 | 
 97 |   function addToSprint(sprintId, projIsssue, cb) {
 98 |     var data = {
 99 |       'fields': {}
100 |     };
101 | 
102 |     if (!config.edit_meta || !config.edit_meta.sprint) {
103 |       return cb('sprint field not found');
104 |     }
105 | 
106 |     data.fields[config.edit_meta.sprint.name] = config.edit_meta.sprint.type === 'number' ? Number(sprintId) : sprintId;
107 |     sslRequest.put(config.auth.url + '/rest/api/2/issue/' + projIsssue).send(data).end((err, res) => {
108 |       try {
109 |         if (!res.ok) {
110 |           console.log('Error getting rapid boards. HTTP Status Code: ' + res.status);
111 |           console.dir(res.body);
112 |           return cb();
113 |         }
114 |       } catch(e) {
115 |         if (err && err.message) {
116 |           return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
117 |         }
118 |         return cb(e);
119 |       }
120 | 
121 |       console.log('Added [' + projIsssue + '] to sprint with id ' + sprintId);
122 |       return cb();
123 |     });
124 |   } //exporting from file
125 | 
126 | 
127 |   return addToSprint;
128 | }();
129 | 


--------------------------------------------------------------------------------
/lib/jira/assign.js:
--------------------------------------------------------------------------------
 1 | /*global console*/
 2 | module.exports = function () {
 3 |   var sslRequest = require('../../lib/ssl_request');
 4 |   const utils = require('../utils');
 5 |   var config = require('../../lib/config');
 6 | 
 7 |   const UNASSIGN_DEFAULT_TEXT = 'null';
 8 | 
 9 |   var assign = {
10 |     query: null,
11 |     table: null,
12 |     to: function (ticket, assignee, cb) {
13 |       const unassignText = config.assign && config.assign.unassignText ? config.assign.unassignText : UNASSIGN_DEFAULT_TEXT;
14 |       if(assignee === unassignText) {
15 |         assignee = null;
16 |       }
17 |       this.query = 'rest/api/2/issue/' + ticket + '/assignee';
18 |       sslRequest
19 |         .put(config.auth.url + this.query)
20 |         .send({ 'name': assignee })
21 |         .set('Content-Type', 'application/json')
22 |         .set('Authorization', 'Basic ' + config.auth.token)
23 |         .end((err, res) => {
24 |           try {
25 |             if (!res.ok) {
26 |               const errorMessages = utils.extractErrorMessages(res).join('\n');
27 |               return console.log(errorMessages);
28 |             }
29 |           } catch(e) {
30 |             if (err && err.message) {
31 |               return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
32 |             }
33 |             return cb(e);
34 |           }
35 |           return console.log('Issue [' + ticket + '] assigned to ' + assignee + '.');
36 |         });
37 |     },
38 |     me: function (ticket, cb) {
39 |       this.to(ticket, config.auth.user, cb);
40 |     }
41 |   };
42 |   return assign;
43 | }();
44 | 


--------------------------------------------------------------------------------
/lib/jira/comment.js:
--------------------------------------------------------------------------------
 1 | /*global requirejs,console,define,fs*/
 2 | module.exports = function () {
 3 |   var sslRequest = require('../../lib/ssl_request');
 4 |   var config = require('../../lib/config');
 5 | 
 6 |   var comment = {
 7 |     query: null,
 8 |     table: null,
 9 |     to: function (issue, comment, cb) {
10 |       this.query = 'rest/api/latest/issue/' + issue + '/comment';
11 |       sslRequest.post(config.auth.url + this.query).send({
12 |         body: comment
13 |       }).end((err, res) => {
14 |         try {
15 |           if (!res.ok) {
16 |             return console.log((res.body.errorMessages || [res.error]).join('\n'));
17 |           }
18 |         } catch(e) {
19 |           if (err && err.message) {
20 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
21 |           }
22 |           return cb(e);
23 |         }
24 | 
25 |         return console.log('Comment to issue [' + issue + '] was posted!.');
26 |       });
27 |     },
28 |     show: function (issue, cb) {
29 |       var that = this,
30 |         i = 0;
31 |       this.query = 'rest/api/latest/issue/' + issue + '/comment';
32 |       sslRequest
33 |         .get(config.auth.url + this.query)
34 |         .end((err, res) => {
35 |           try {
36 |             if (!res.ok) {
37 |               return console.log(res.body.errorMessages.join('\n'));
38 |             }
39 |           } catch(e) {
40 |             if (err && err.message) {
41 |               return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
42 |             }
43 |             return cb(e);
44 |           }
45 | 
46 |           if (res.body.total > 0) {
47 |             for (i = 0; i < res.body.total; i += 1) {
48 |               var updated = new Date(res.body.comments[i].updated);
49 |               updated = ' (' + updated + ')';
50 |               console.log('\n' + res.body.comments[i].author.displayName.cyan + updated.grey);
51 |               console.log(res.body.comments[i].body);
52 |             }
53 |           } else {
54 |             return console.log('There are no comments on this issue.');
55 |           }
56 |         });
57 |     }
58 |   };
59 |   return comment;
60 | }();
61 | 


--------------------------------------------------------------------------------
/lib/jira/create.js:
--------------------------------------------------------------------------------
  1 | /*global*/
  2 | module.exports = function (jira) {
  3 |   const promptly = require('promptly');
  4 |   const utils = require('../utils');
  5 | 
  6 |   function printError (messages) {
  7 |     console.log(messages.join('\n'));
  8 |   }
  9 | 
 10 |   var create = {
 11 |     query: null,
 12 |     table: null,
 13 |     isSubTask: false,
 14 |     projects: [],
 15 |     priorities: [],
 16 |     answers: {
 17 |       fields: {}
 18 |     },
 19 |     ask: function (question, callback, yesno, values, answer) {
 20 |       var that = this,
 21 |         issueTypes = [],
 22 |         i = 0;
 23 | 
 24 |       if (answer || answer === false) {
 25 |         return callback(answer);
 26 |       }
 27 | 
 28 |       if (values && values.length > 0) {
 29 |         for (i; i < values.length; i++) {
 30 |           if (that.isSubTask) {
 31 |             if (values[i].subtask !== undefined) {
 32 |               if (values[i].subtask) {
 33 |                 issueTypes.push('(' + values[i].id + ') ' + values[i].name);
 34 |               }
 35 |             } else {
 36 |               issueTypes.push('(' + values[i].id + ') ' + values[i].name);
 37 |             }
 38 |           } else {
 39 |             if (!values[i].subtask) {
 40 |               issueTypes.push('(' + values[i].id + ') ' + values[i].name);
 41 |             }
 42 |           }
 43 |         }
 44 | 
 45 |         console.log(issueTypes.join('\n'));
 46 |       }
 47 | 
 48 |       promptly
 49 |         .prompt(question)
 50 |         .then(answer => {
 51 |           if (answer.length > 0) {
 52 |             callback(answer);
 53 |           } else {
 54 |             if (yesno) {
 55 |               callback(false);
 56 |             } else {
 57 |               that.ask(question, callback);
 58 |             }
 59 |           }
 60 |         })
 61 |         .catch(e => {
 62 |           if(e && e.message === 'canceled') {
 63 |             console.log('\nInput cancelled');
 64 |           } else {
 65 |             console.log('\nError: ' + e.toString());
 66 |           }
 67 |         });
 68 |     },
 69 |     askProject: function (project, callback) {
 70 |       var that = this,
 71 |         i = 0;
 72 |       this.ask('Type the project name or key: ', function (answer) {
 73 |         var projectId = 0,
 74 |           index = 0;
 75 |         answer = answer.charAt(0).toUpperCase() + answer.substring(1).toLowerCase();
 76 | 
 77 |         for (i; i < that.projects.length; i++) {
 78 |           if (answer == that.projects[i].key || answer.toUpperCase() == that.projects[i].key) {
 79 |             projectId = that.projects[i].id;
 80 |             index = i;
 81 |           } else if (answer == that.projects[i].name) {
 82 |             projectId = that.projects[i].id;
 83 |             index = i;
 84 |           }
 85 |         }
 86 | 
 87 |         if (projectId > 0) {
 88 |           callback(projectId, index);
 89 |         } else {
 90 |           console.log('Project "' + answer + '" does not exists.');
 91 |           that.askProject(project, callback);
 92 |         }
 93 |       }, null, null, project);
 94 |     },
 95 |     askSubTask: function (subtask, callback) {
 96 |       var that = this;
 97 |       that.ask('Type the parent task key (only the numbers) if exists, otherwise press enter: ', function (answer) {
 98 |         if (answer === false || parseInt(answer) > 0) {
 99 |           that.isSubTask = answer ? true : false;
100 |           callback(answer);
101 |         } else {
102 |           console.log('Please, type only the task number (ex: if issue is "XXX-324", type only "324").');
103 |           that.askSubTask(subtask, callback);
104 |         }
105 |       }, true, null, subtask);
106 |     },
107 |     askIssueType: function (type, callback) {
108 |       var that = this,
109 |         issueTypeArray = that.project.issuetypes;
110 |       that.ask('Select issue type: ', function (issueType) {
111 |         callback(issueType);
112 |       }, false, issueTypeArray, type);
113 |     },
114 |     askIssuePriorities: function (priority, callback) {
115 |       var that = this,
116 |         issuePriorities = that.priorities;
117 |       that.ask('Select the priority: ', function (issuePriority) {
118 |         callback(issuePriority);
119 |       }, false, issuePriorities, priority);
120 |     },
121 |     newIssue: function (projIssue, options) {
122 |       var that = this;
123 |       var project = typeof projIssue === 'string' ? projIssue : undefined;
124 |       var parent = undefined;
125 | 
126 |       if (project !== undefined) {
127 |         var split = project.split('-');
128 |         project = split[0];
129 | 
130 |         if (split.length > 1) {
131 |           parent = split[1];
132 |           console.log('Creating subtask for issue ' + projIssue);
133 |         } else {
134 |           console.log('Creating issue in project ' + project);
135 |         }
136 |       }
137 |       this.getMeta(function (error, meta) {
138 |         if (error) {
139 |           printError(error.messages);
140 |           process.stdin.destroy();
141 |           return;
142 |         }
143 |         that.projects = meta;
144 |         that.askProject(options.project, function (projectId, index) {
145 |           that.project = that.projects[index];
146 |           that.answers.fields.project = {
147 |             id: projectId
148 |           };
149 | 
150 |           if (!options.subtask && (options.priority || options.type || options.summary || options.description)) {
151 |             options.subtask = false;
152 |           }
153 | 
154 |           that.askSubTask(options.subtask, function (taskKey) {
155 |             if (taskKey) {
156 |               that.answers.fields.parent = {
157 |                 key: that.project.key + '-' + taskKey
158 |               };
159 |             }
160 | 
161 |             that.askIssueType(options.type, function (issueTypeId) {
162 |               that.answers.fields.issuetype = {
163 |                 id: issueTypeId
164 |               };
165 |               that.ask('Type the issue summary: ', function (issueSummary) {
166 |                 that.answers.fields.summary = issueSummary;
167 |                 that.ask('Type the issue description: ', function (issueDescription) {
168 |                   var defaultAnswer = issueSummary;
169 | 
170 |                   if (!issueDescription) {
171 |                     that.answer.fields.description = defaultAnswer;
172 |                   } else {
173 |                     that.answers.fields.description = issueDescription;
174 |                   }
175 | 
176 |                   process.stdin.destroy();
177 |                   that.saveIssue(options);
178 |                 }, null, null, options.description);
179 |               }, null, null, options.summary);
180 |             });
181 |           });
182 |         });
183 |       });
184 |     },
185 |     getMeta: function (callback) {
186 |       jira.issue.getCreateMetadata({})
187 |         .then(data => {
188 |           callback(undefined, data.projects);
189 |         }, response => {
190 |           callback({ messages: utils.extractErrorMessages(response) }, undefined);
191 |         });
192 |     },
193 | 
194 |     saveIssue: function () {
195 |       jira.issue.createIssue(this.answers)
196 |         .then(data => {
197 |           console.log(`Issue ${data.key} created successfully!`);
198 |         }, response => {
199 |           const errorMessages = utils.extractErrorMessages(response);
200 |           printError(errorMessages);
201 |         });
202 |     }
203 |   };
204 |   return create;
205 | };
206 | 


--------------------------------------------------------------------------------
/lib/jira/describe.js:
--------------------------------------------------------------------------------
  1 | /*global requirejs,console,define,fs*/
  2 | module.exports = function () {
  3 |   var sslRequest = require('../../lib/ssl_request');
  4 | 
  5 |   var Table = require('cli-table');
  6 | 
  7 |   var openurl = require('openurl');
  8 | 
  9 |   var url = require('url');
 10 | 
 11 |   var config = require('../../lib/config');
 12 | 
 13 |   var describe = {
 14 |     query: null,
 15 |     priority: null,
 16 |     table: null,
 17 |     getIssueField: function (field, cb) {
 18 |       var that = this;
 19 |       sslRequest.get(config.auth.url + this.query + '?fields=' + field).end((err, res) => {
 20 |         try {
 21 |           if (!res.ok) {
 22 |             return console.log(res);
 23 |           }
 24 |         } catch(e) {
 25 |           if (err && err.message) {
 26 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
 27 |           }
 28 |           return cb(e);
 29 |         }
 30 | 
 31 |         if (res.body.fields) {
 32 |           if (typeof res.body.fields[field] === 'string') {
 33 |             console.log(res.body.fields[field]);
 34 |           } else {
 35 |             console.log(res.body.fields[field].name);
 36 |           }
 37 |         } else {
 38 |           console.log('Field does not exist.');
 39 |         }
 40 |       });
 41 |     },
 42 |     getIssue: function (cb) {
 43 |       var that = this;
 44 |       sslRequest.get(config.auth.url + this.query).end((err, res) => {
 45 |         try {
 46 |           if (!res.ok) {
 47 |             //return console.log(res.body.errorMessages.join('\n'));
 48 |             return console.log(res);
 49 |           }
 50 |         } catch(e) {
 51 |           if (err && err.message) {
 52 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
 53 |           }
 54 |           return cb(e);
 55 |         }
 56 | 
 57 |         that.table = new Table();
 58 |         that.priority = res.body.fields.priority;
 59 |         that.description = res.body.fields.description;
 60 | 
 61 |         if (!that.priority) {
 62 |           that.priority = {
 63 |             name: ''
 64 |           };
 65 |         }
 66 | 
 67 |         if (!that.description) {
 68 |           that.description = 'No description';
 69 |         }
 70 | 
 71 |         that.table.push({
 72 |           'Issue': res.body.key
 73 |         }, {
 74 |           'Summary': res.body.fields.summary
 75 |         }, {
 76 |           'Type': res.body.fields.issuetype.name
 77 |         }, {
 78 |           'Priority': that.priority.name
 79 |         }, {
 80 |           'Status': res.body.fields.status.name
 81 |         }, {
 82 |           'Reporter': res.body.fields.reporter.displayName + ' <' + res.body.fields.reporter.emailAddress + '> '
 83 |         }, {
 84 |           'Assignee': (res.body.fields.assignee ? res.body.fields.assignee.displayName : 'Not Assigned') + ' <' + (res.body.fields.assignee ? res.body.fields.assignee.emailAddress : '') + '> '
 85 |         }, {
 86 |           'Labels': res.body.fields.labels ? res.body.fields.labels.join(', ') : ''
 87 |         }, {
 88 |           'Subtasks': res.body.fields.subtasks.length
 89 |         }, {
 90 |           'Comments': res.body.fields.comment.total
 91 |         });
 92 |         console.log(that.table.toString());
 93 |         console.log('\r\n' + that.description + '\r\n');
 94 |       });
 95 |     },
 96 |     open: function (issue) {
 97 |       openurl.open(url.resolve(config.auth.url, 'browse/' + issue));
 98 |     },
 99 |     show: function (issue, field, cb) {
100 |       this.query = 'rest/api/latest/issue/' + issue;
101 | 
102 |       if (field) {
103 |         return this.getIssueField(field, cb);
104 |       } else {
105 |         return this.getIssue(cb);
106 |       }
107 |     }
108 |   };
109 |   return describe;
110 | }();
111 | 


--------------------------------------------------------------------------------
/lib/jira/edit.js:
--------------------------------------------------------------------------------
  1 | /*global requirejs,console,define,fs*/
  2 | module.exports = function () {
  3 |   const promptly = require('promptly');
  4 | 
  5 |   var sslRequest = require('../../lib/ssl_request');
  6 | 
  7 |   var config = require('../../lib/config');
  8 | 
  9 |   var common = require('../../lib/common');
 10 | 
 11 |   var async = require('async');
 12 | 
 13 |   var editMeta = {
 14 |     ask: function (question, callback, yesno, values, answer) {
 15 |       var that = this,
 16 |         issueTypes = [],
 17 |         i = 0;
 18 | 
 19 |       if (answer || answer === false) {
 20 |         return callback(answer);
 21 |       }
 22 | 
 23 |       if (values && values.length > 0) {
 24 |         for (i; i < values.length; i++) {
 25 |           if (that.isSubTask) {
 26 |             if (values[i].subtask !== undefined) {
 27 |               if (values[i].subtask) {
 28 |                 issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 29 |               }
 30 |             } else {
 31 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 32 |             }
 33 |           } else {
 34 |             if (!values[i].subtask) {
 35 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 36 |             }
 37 |           }
 38 |         }
 39 | 
 40 |         console.log(issueTypes.join('\n'));
 41 |       }
 42 | 
 43 |       var match;
 44 |       promptly
 45 |         .prompt(question)
 46 |         .then(answer => {
 47 |           debugger;
 48 |   
 49 |           if (answer.length > 0) {
 50 |             values && values.forEach(function (eachValue) {
 51 |               if (eachValue.id == answer || eachValue.value == answer || eachValue.name == answer) {
 52 |                 answer = eachValue.value;
 53 |                 match = true;
 54 |               }
 55 |             });
 56 |   
 57 |             if (values) {
 58 |               if (match) {
 59 |                 return callback(answer);
 60 |               } else {
 61 |                 editMeta.ask(question, callback, yesno, values);
 62 |               }
 63 |             } else {
 64 |               return callback(answer);
 65 |             }
 66 |           } else {
 67 |             if (yesno) {
 68 |               callback(false);
 69 |             } else {
 70 |               editMeta.ask(question, callback);
 71 |             }
 72 |           }
 73 |         })
 74 |         .catch(e => {
 75 |           if(e && e.message === 'canceled') {
 76 |             console.log('\nInput cancelled');
 77 |           } else {
 78 |             console.log('\nError: ' + e.toString());
 79 |           }
 80 |         });
 81 |     },
 82 |     getMeta: function (issue, callback) {
 83 |       this.query = 'rest/api/2/issue/' + issue + '/editmeta';
 84 |       sslRequest.get(config.auth.url + this.query).end((err, res) => {
 85 |         try {
 86 |           if (!res.ok) {
 87 |             console.log((res.body.errorMessages || [res.error]).join('\n'));
 88 |             return callback((res.body.errorMessages || [res.error]).join('\n'));
 89 |           }
 90 |         } catch(e) {
 91 |           if (err && err.message) {
 92 |             return callback(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
 93 |           }
 94 |           return callback(e);
 95 |         }
 96 | 
 97 |         callback(null, res.body.fields);
 98 |       });
 99 |     },
100 |     getOutputFormat: function (meta, issue, field, value, putBody, cb) {
101 |       //handling without callback scenarios
102 |       if (!cb) {
103 |         cb = function (err, result) {
104 |           if (err) {
105 |             throw err;
106 |           } else {
107 |             return result;
108 |           }
109 |         };
110 |       }
111 | 
112 |       var editing = meta[field];
113 | 
114 |       if (!editing || !editing.schema) {
115 |         return cb(new Error('wrong meta'));
116 |       }
117 | 
118 |       if (!putBody.fields) {
119 |         putBody.fields = {};
120 |       }
121 | 
122 |       var formattedValue;
123 | 
124 |       if (editing.schema.type == 'string') {
125 |         formattedValue = value.toString();
126 |       } else if (editing.schema.type == 'array') {
127 |         //how to give multiple inputs
128 |         if (editing.schema.items == 'string') {
129 |           formattedValue = value.toString().split(',');
130 |         }
131 |       } else if (editing.schema.type == 'any') {
132 |         console.log('not yet supported');
133 |       } else if (editing.schema.type == 'priority') {
134 |         formattedValue = {
135 |           id: value
136 |         };
137 |       }
138 | 
139 |       if (!formattedValue) {
140 |         return cb(new Error('this type of field is not supported yet'));
141 |       }
142 | 
143 |       putBody.fields[field] = formattedValue;
144 |       return cb(null, putBody);
145 |     },
146 |     makeEditCall: function (issue, putbody, cb) {
147 |       this.query = 'rest/api/2/issue/' + issue;
148 |       sslRequest.put(config.auth.url + this.query).send(putbody).end((err, res) => {
149 |         try {
150 |           if (!res.ok) {
151 |             console.log(res);
152 | 
153 |             if (res.body && res.body.errorMessages) {
154 |               console.log(res.body && res.body.errorMessages && res.body.errorMessages.join('\n'));
155 |               return cb(res.body.errorMessages.join('\n'));
156 |             }
157 | 
158 |             return cb(new Error('some error'));
159 |           }
160 |         } catch(e) {
161 |           if (err && err.message) {
162 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
163 |           }
164 |           return cb(e);
165 |         }
166 | 
167 |         console.log('Issue edited successfully!');
168 |         return cb();
169 |       });
170 |     },
171 |     editWithInputPutBody: function (issue, input, cb) {
172 |       editMeta.getMeta(issue, function (err, meta) {
173 |         if (err) {
174 |           return cb(err);
175 |         }
176 | 
177 |         var putBody = {};
178 | 
179 |         if (config && config.edit_meta && config.edit_meta['__default'] && config.edit_meta['__default'][input]) {
180 |           putBody = config.edit_meta['__default'][input];
181 |         } else {
182 |           var parsedInputMap = editMeta.parseEditInput(input);
183 |           Object.keys(parsedInputMap).forEach(function (eachField) {
184 |             putBody = editMeta.getOutputFormat(meta, issue, eachField, parsedInputMap[eachField], putBody);
185 |           });
186 |         }
187 | 
188 |         editMeta.makeEditCall(issue, putBody, cb);
189 |       });
190 |     },
191 |     parseEditInput: function (input) {
192 |       var inputArr = input.toString().split(';;');
193 |       var singleInput, inputKey, inputValue, finalKey, finalValue;
194 |       var inputObj = {};
195 |       inputArr.forEach(function (eachInput) {
196 |         singleInput = eachInput.split('::');
197 |         inputKey = singleInput[0];
198 |         inputValue = singleInput[1];
199 | 
200 |         if (config && config.edit_meta && config.edit_meta[inputKey]) {
201 |           if (config.edit_meta[inputKey].key) {
202 |             finalKey = config.edit_meta[inputKey].key;
203 |           }
204 | 
205 |           if (config.edit_meta[inputKey].default && config.edit_meta[inputKey].default[inputValue]) {
206 |             finalValue = config.edit_meta[inputKey].default[inputValue];
207 |           }
208 |         } else {
209 |           finalKey = inputKey;
210 |           finalValue = inputValue;
211 |         }
212 | 
213 |         inputObj[finalKey] = finalValue;
214 |       });
215 |       return inputObj;
216 |     },
217 |     edit: function (issue, cb) {
218 |       editMeta.getMeta(issue, function (err, meta) {
219 |         if (err) {
220 |           return cb(err);
221 |         }
222 | 
223 |         var metaInput = [];
224 |         Object.keys(meta).forEach(function (eachMeta, index) {
225 |           metaInput.push({
226 |             id: index,
227 |             value: eachMeta,
228 |             name: meta[eachMeta].name
229 |           });
230 |         });
231 |         editMeta.ask('enter Input ', function (answer) {
232 |           console.log(answer);
233 |           var inputOptions;
234 | 
235 |           if (meta[answer] && meta[answer].allowedValues && meta[answer].allowedValues.length) {
236 |             inputOptions = meta[answer].allowedValues;
237 |           }
238 | 
239 |           common.ask('Enter value ', function (answerValue) {
240 |             var putBody = {};
241 |             editMeta.getOutputFormat(meta, issue, answer, answerValue, putBody, function (err, putBody) {
242 |               if (err) {
243 |                 return cb(err);
244 |               }
245 | 
246 |               editMeta.makeEditCall(issue, putBody, cb);
247 |             });
248 |           }, null, inputOptions);
249 |         }, null, metaInput);
250 |       });
251 |     }
252 |   };
253 |   return editMeta;
254 | }();
255 | 


--------------------------------------------------------------------------------
/lib/jira/fix.js:
--------------------------------------------------------------------------------
 1 | /*global requirejs,console,define,fs*/
 2 | module.exports = function () {
 3 |   var sslRequest = require('../../lib/ssl_request');
 4 | 
 5 |   var config = require('../../lib/config');
 6 | 
 7 |   var fix = {
 8 |     query: null,
 9 |     to: function (ticket, version, cb) {
10 |       this.query = 'rest/api/2/issue/' + ticket;
11 |       sslRequest.put(config.auth.url + this.query).send({
12 |         'update': {
13 |           'fixVersions': [{
14 |             'set': [{
15 |               'name': version
16 |             }]
17 |           }]
18 |         }
19 |       }).end((err, res) => {
20 |         try {
21 |           if (!res.ok) {
22 |             return console.log((res.body.errorMessages || [res.error]).join('\n'));
23 |           }
24 |         } catch(e) {
25 |           if (err && err.message) {
26 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
27 |           }
28 |           return cb(e);
29 |         }
30 | 
31 |         return console.log('FixVersion [' + ticket + '] set to ' + version + '.');
32 |       });
33 |     },
34 |     append: function (ticket, version, cb) {
35 |       this.query = 'rest/api/2/issue/' + ticket;
36 |       sslRequest.put(config.auth.url + this.query).send({
37 |         'update': {
38 |           'fixVersions': [{
39 |             'add': {
40 |               'name': version
41 |             }
42 |           }]
43 |         }
44 |       }).end((err, res) => {
45 |         try {
46 |           if (!res.ok) {
47 |             return console.log((res.body.errorMessages || [res.error]).join('\n'));
48 |           }
49 |         } catch(e) {
50 |           if (err && err.message) {
51 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
52 |           }
53 |           return cb(e);
54 |         }
55 | 
56 |         return console.log('Appended FixVersion ' + version + ' to [' + ticket + '].');
57 |       });
58 |     }
59 |   };
60 |   return fix;
61 | }();
62 | 


--------------------------------------------------------------------------------
/lib/jira/link.js:
--------------------------------------------------------------------------------
  1 | module.exports = function () {
  2 |   const promptly = require('promptly');
  3 | 
  4 |   var sslRequest = require('../../lib/ssl_request');
  5 | 
  6 |   var config = require('../../lib/config');
  7 | 
  8 |   var answers;
  9 |   function ask(question, callback, yesno, values, options) {
 10 |     var that = this,
 11 |       issueTypes = [],
 12 |       i = 0; //from command if provided
 13 | 
 14 |     if (values && values.length > 0) {
 15 |       for (i; i < values.length; i++) {
 16 |         if (that.isSubTask) {
 17 |           if (values[i].subtask !== undefined) {
 18 |             if (values[i].subtask) {
 19 |               issueTypes.push('(' + values[i].id + ') ' + options.from + ' ' + values[i].outward + ' ' + options.to);
 20 |             }
 21 |           } else {
 22 |             issueTypes.push('(' + values[i].id + ') ' + options.from + ' ' + values[i].outward + ' ' + options.to);
 23 |           }
 24 |         } else {
 25 |           if (!values[i].subtask) {
 26 |             issueTypes.push('(' + values[i].id + ') ' + options.from + ' ' + values[i].outward + ' ' + options.to);
 27 |           }
 28 |         }
 29 |       }
 30 | 
 31 |       console.log(issueTypes.join('\n'));
 32 |     }
 33 |     
 34 |     promptly
 35 |       .prompt(question)
 36 |       .then(answer => {
 37 |         if (answer.length > 0) {
 38 |           callback(answer);
 39 |         } else {
 40 |           if (yesno) {
 41 |             callback(false);
 42 |           } else {
 43 |             that.ask(question, callback);
 44 |           }
 45 |         }
 46 |       })
 47 |       .catch(e => {
 48 |         if(e && e.message === 'canceled') {
 49 |           console.log('\nInput cancelled');
 50 |         } else {
 51 |           console.log('\nError: ' + e.toString());
 52 |         }
 53 |       });
 54 |   }
 55 | 
 56 |   function askLinkType(options, cb) {
 57 |     getLinkType(function (linkTypes) {
 58 |       ask(
 59 |         'Select the linktype: ',
 60 |         function (link) {
 61 |           if(link) {
 62 |             cb(link);
 63 |           }
 64 |         },
 65 |         false,
 66 |         linkTypes,
 67 |         options);
 68 |     });
 69 |   }
 70 | 
 71 |   function getLinkType(cb) {
 72 |     this.query = 'rest/api/2/issueLinkType';
 73 |     sslRequest
 74 |       .get(config.auth.url + this.query)
 75 |       .end((err, res) => {
 76 |         try {
 77 |           if (!res.ok) {
 78 |             return console.log(res.body.errorMessages.join('\n'));
 79 |           }
 80 |         } catch(e) {
 81 |           if (err && err.message) {
 82 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
 83 |           }
 84 |           return cb(e);
 85 |         }
 86 | 
 87 |         return cb(res.body.issueLinkTypes);
 88 |       });
 89 |   }
 90 | 
 91 |   function callLink(reqOpts, cb) {
 92 |     this.query = 'rest/api/2/issueLink';
 93 |     sslRequest
 94 |       .post(config.auth.url + this.query)
 95 |       .send(JSON.stringify(reqOpts))
 96 |       .end((err, res) => {
 97 |         try {
 98 |           if (!res.ok) {
 99 |             return console.log(res.body.errorMessages.join('\n'));
100 |           }
101 |         } catch(e) {
102 |           if (err && err.message) {
103 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
104 |           }
105 |           return cb(e);
106 |         }
107 |         console.log('Issues linked');
108 |         return cb();
109 |       });
110 |   }
111 | 
112 |   return function link(from, to, link_value, options, cb) {
113 |     var reqOpts = {
114 |       'type': {
115 |         'name': 'Relate'
116 |       },
117 |       'inwardIssue': {
118 |         'key': from
119 |       },
120 |       'outwardIssue': {
121 |         'key': to
122 |       },
123 |       'comment': {
124 |         'body': 'Linked related issue!'
125 |       }
126 |     };
127 |     options.from = from;
128 |     options.to = to;
129 |     options.link_value = link_value;
130 |     if(!options.link_value) {
131 |       askLinkType(options, function (linkname) {
132 |         reqOpts.type.id = linkname;
133 |         callLink(reqOpts, cb);
134 |       });
135 |     } else {
136 |       reqOpts.type.id = options.link_value;
137 |       callLink(reqOpts, cb);
138 |     }
139 |   };
140 | }();
141 | 


--------------------------------------------------------------------------------
/lib/jira/ls.js:
--------------------------------------------------------------------------------
  1 | /*global requirejs,define,fs*/
  2 | 
  3 | /*
  4 |  * ./bin/jira.js jql -c "assignee=currentUser()" -s status
  5 |  * ./bin/jira.js jql -j 1  "reporter=currentUser() and status='done' and createdDate>'2017-01-01' and createdDate<'2018-04-01'"
  6 |  * ./bin/jira.js jql -j 1  "assignee=currentUser() and createdDate>'2017-01-01' and createdDate<'2018-04-01'"
  7 |  * */
  8 | module.exports = function () {
  9 |   var Table = require('cli-table');
 10 | 
 11 |   var config = require('../../lib/config');
 12 | 
 13 |   var async = require('async');
 14 | 
 15 |   var alasql = require('alasql');
 16 | 
 17 |   var sslRequest = require('../../lib/ssl_request');
 18 | 
 19 |   var ls = {
 20 |     project: null,
 21 |     query: null,
 22 |     type: null,
 23 |     issues: null,
 24 |     table: null,
 25 |     callIssueApi: function (options, cb) {
 26 |       var that = this,
 27 |         i = 0;
 28 |       var allIssues = [];
 29 |       var currentLength = 0;
 30 |       var currentOffset = 0;
 31 |       var currentLimit = 500;
 32 |       async.doWhilst(function (callback) {
 33 |         currentLength = 0;
 34 |         var rq = config.auth.url + that.query + '&startAt=' + currentOffset + '&maxResults=' + currentLimit;
 35 | 
 36 |         if (options && options.verbose) {
 37 |           console.log(rq);
 38 |         }
 39 |         sslRequest.get(rq).end((err, res) => {
 40 |           try {
 41 |             if (!res.ok) {
 42 |               return callback((res.body.errorMessages || [res.error]).join('\n'));
 43 |             }
 44 |           } catch(e) {
 45 |             if (err && err.message) {
 46 |               return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
 47 |             }
 48 |             return cb(e);
 49 |           }
 50 | 
 51 |           allIssues.push.apply(allIssues, res.body.issues);
 52 |           currentLength = res.body.issues.length;
 53 |           currentOffset += currentLength;
 54 |           return callback();
 55 |         });
 56 |       }, function () {
 57 |         return currentLength == currentLimit;
 58 |       }, function (err) {
 59 |         return cb(null, allIssues);
 60 |       });
 61 |     },
 62 |     getIssues: function (options, cb) {
 63 |       if (!cb) {
 64 |         cb = options;
 65 |         options = null;
 66 |       }
 67 | 
 68 |       var that = this,
 69 |         i = 0;
 70 |       this.callIssueApi(options, function (err, issues) {
 71 |         if (err) {
 72 |           return cb(err);
 73 |         }
 74 | 
 75 |         if (options && options.json) {
 76 |           return cb(null, issues);
 77 |         }
 78 | 
 79 |         that.issues = issues;
 80 |         that.table = new Table({
 81 |           head: ['Key', 'Priority', 'Summary', 'Status', 'FixVersions'],
 82 |           chars: {
 83 |             'top': '',
 84 |             'top-mid': '',
 85 |             'top-left': '',
 86 |             'top-right': '',
 87 |             'bottom': '',
 88 |             'bottom-mid': '',
 89 |             'bottom-left': '',
 90 |             'bottom-right': '',
 91 |             'left': '',
 92 |             'left-mid': '',
 93 |             'mid': '',
 94 |             'mid-mid': '',
 95 |             'right': '',
 96 |             'right-mid': ''
 97 |           },
 98 |           style: {
 99 |             'padding-left': 1,
100 |             'padding-right': 1,
101 |             head: ['cyan'],
102 |             compact: true
103 |           }
104 |         });
105 | 
106 |         for (i = 0; i < that.issues.length; i += 1) {
107 |           var priority = that.issues[i].fields.priority,
108 |             summary = that.issues[i].fields.summary,
109 |             status = that.issues[i].fields.status;
110 | 
111 |           if (!priority) {
112 |             priority = {
113 |               name: ''
114 |             };
115 |           }
116 | 
117 |           if (summary.length > 50) {
118 |             summary = summary.substr(0, 47) + '...';
119 |           }
120 | 
121 |           if (that.issues[i].fields.fixVersions.length) {
122 |             fv = that.issues[i].fields.fixVersions.map(function (elem) {
123 |               return elem.name;
124 |             }).join(',');
125 |             that.table.push([that.issues[i].key, priority.name, summary, status.name, fv]);
126 |           } else {
127 |             that.table.push([that.issues[i].key, priority.name, summary, status.name, 'n/a']);
128 |           }
129 |         }
130 | 
131 |         if (that.issues.length > 0) {
132 |           //dont print if no_print is set
133 |           if (!(options && options.no_print)) {
134 |             console.log(that.table.toString());
135 |           }
136 |         } else {
137 |           console.log('No issues');
138 |         }
139 | 
140 |         return cb(null, that.issues);
141 |       });
142 |     },
143 |     showAll: function (options, cb) {
144 |       this.type = options && options.type ? '+AND+type="' + options.type + '"' : '';
145 |       this.query = 'rest/api/2/search?jql=' + 'assignee=currentUser()' + this.type + '+AND+status+in+("' + this.getAvailableStatuses() + '")' + '+order+by+key+DESC' + '&maxResults=500';
146 |       return this.getIssues(options, cb);
147 |     },
148 |     showInProgress: function (cb) {
149 |       this.query = 'rest/api/2/search?jql=' + 'assignee=currentUser()' + '+AND+status+in+("In+Progress")' + '+order+by+priority+DESC,+key+ASC';
150 |       return this.getIssues(cb);
151 |     },
152 |     showByProject: function (options, cb) {
153 |       this.type = options && options.type ? '+AND+type=' + options.type : '';
154 |       var project = options && options.project ? '+AND+project=' + options.project : '';
155 |       this.query = 'rest/api/2/search?jql=' + 'assignee=currentUser()' + this.type + project + '+AND+status+in+("' + this.getAvailableStatuses() + '")' + '+order+by+priority+DESC,+key+ASC';
156 |       return this.getIssues(cb);
157 |     },
158 |     search: function (query, cb) {
159 |       this.query = 'rest/api/2/search?jql=' + 'summary+~+"' + query + '"' + '+OR+description+~+"' + query + '"' + '+OR+comment+~+"' + query + '"' + '+order+by+priority+DESC,+key+ASC';
160 |       return this.getIssues(cb);
161 |     },
162 |     jqlSearch: function (jql, options, cb) {
163 |       var query;
164 | 
165 |       if (options && options.custom) {
166 |         if (config.custom_jql && config.custom_jql[options.custom]) {
167 |           query = config.custom_jql[options.custom];
168 |         } else {
169 |           query = options.custom;
170 |         }
171 |       } else {
172 |         if (config.custom_jql && config.custom_jql[jql]) {
173 |           query = config.custom_jql[jql];
174 |         } else {
175 |           query = jql;
176 |         }
177 |       }
178 | 
179 |       this.query = 'rest/api/2/search?jql=' + encodeURIComponent(query);
180 |       return this.getIssues(options, cb);
181 |     },
182 |     getAvailableStatuses: function () {
183 |       return config.options.available_issues_statuses.join('", "');
184 |     },
185 |     aggregateResults: function (jql, options, cb) {
186 |       if (!options) {
187 |         options = {};
188 |       }
189 | 
190 |       options.json = true;
191 |       this.jqlSearch(jql, options, function (err, issues) {
192 |         if (err) {
193 |           return cb(err);
194 |         }
195 | 
196 |         var query;
197 | 
198 |         if (options && options.custom_sql) {
199 |           if (config.custom_alasql && config.custom_alasql[options.custom_sql]) {
200 |             query = config.custom_alasql[options.custom_sql];
201 |           } else {
202 |             query = options.custom_sql;
203 |           }
204 |         } else {
205 |           return cb(new Error('no custom sql found'));
206 |         }
207 | 
208 |         var result = [];
209 | 
210 |         try {
211 |           console.log(query);
212 |           result = alasql(query, [issues]);
213 |         } catch (ex) {
214 |           return cb(ex);
215 |         }
216 | 
217 |         if (!result.length) {
218 |           return cb(new Error('No Result'));
219 |         }
220 | 
221 |         var resultTable = new Table({
222 |           head: Object.keys(result[0])
223 |         });
224 |         var eachRow = [];
225 | 
226 |         for (i = 0; i < result.length; i += 1) {
227 |           eachRow = [];
228 |           Object.keys(result[0]).forEach(function (eachKey) {
229 |             eachRow.push(result[i][eachKey] || '');
230 |           });
231 |           resultTable.push(eachRow);
232 |         }
233 | 
234 |         console.log(resultTable.toString());
235 |         return cb(null, result);
236 |       });
237 |     }
238 |   };
239 |   return ls;
240 | }();
241 | 


--------------------------------------------------------------------------------
/lib/jira/new.js:
--------------------------------------------------------------------------------
  1 | /*global, console*/
  2 | module.exports = function () {
  3 |   const promptly = require('promptly');
  4 | 
  5 |   var sslRequest = require('../../lib/ssl_request');
  6 | 
  7 |   var config = require('../../lib/config');
  8 | 
  9 |   var async = require('async');
 10 | 
 11 |   const utils = require('../utils');
 12 | 
 13 |   var create = {
 14 |     query: null,
 15 |     table: null,
 16 |     isSubTask: false,
 17 |     projects: [],
 18 |     projectMeta: {},
 19 |     priorities: [],
 20 |     answers: {
 21 |       fields: {}
 22 |     },
 23 |     ask: function (question, callback, yesno, values, answer) {
 24 |       var that = this,
 25 |         issueTypes = [],
 26 |         i = 0;
 27 | 
 28 |       if (answer || answer === false) {
 29 |         return callback(answer);
 30 |       }
 31 | 
 32 |       if (values && values.length > 0) {
 33 |         for (i; i < values.length; i++) {
 34 |           if (that.isSubTask) {
 35 |             if (values[i].subtask !== undefined) {
 36 |               if (values[i].subtask) {
 37 |                 issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 38 |               }
 39 |             } else {
 40 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 41 |             }
 42 |           } else {
 43 |             if (!values[i].subtask) {
 44 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 45 |             }
 46 |           }
 47 |         }
 48 | 
 49 |         console.log(issueTypes.join('\n'));
 50 |       }
 51 | 
 52 |       promptly
 53 |         .prompt(question)
 54 |         .then(answer => {
 55 |           if (answer.length > 0) {
 56 |             callback(answer);
 57 |           } else {
 58 |             if (yesno) {
 59 |               callback(false);
 60 |             } else {
 61 |               that.ask(question, callback);
 62 |             }
 63 |           }
 64 |         })
 65 |         .catch(e => {
 66 |           if(e && e.message === 'canceled') {
 67 |             console.log('\nInput cancelled');
 68 |           } else {
 69 |             console.log('\nError: ' + e.toString());
 70 |           }
 71 |         });
 72 |     },
 73 |     askProject: function (project, callback) {
 74 |       var that = this,
 75 |         i = 0;
 76 |       this.ask('Type the project name or key: ', function (answer) {
 77 |         var projectId = 0,
 78 |           index = 0;
 79 |         answer = answer.charAt(0).toUpperCase() + answer.substring(1).toLowerCase();
 80 | 
 81 |         for (i; i < that.projects.length; i++) {
 82 |           if (answer === that.projects[i].key || answer.toUpperCase() === that.projects[i].key) {
 83 |             projectId = that.projects[i].id;
 84 |             index = i;
 85 |           } else if (answer === that.projects[i].name) {
 86 |             projectId = that.projects[i].id;
 87 |             index = i;
 88 |           }
 89 |         }
 90 | 
 91 |         if (projectId > 0) {
 92 |           callback(projectId, index, answer.toUpperCase());
 93 |         } else {
 94 |           console.log('Project "' + answer + '" does not exists.');
 95 |           that.askProject(project, callback);
 96 |         }
 97 |       }, false, null, project);
 98 |     },
 99 |     getMeta: function (key, callback) {
100 |       this.query = 'rest/api/2/issue/createmeta';
101 | 
102 |       if (key) {
103 |         this.query += '?projectKeys=' + key + '&expand=projects.issuetypes.fields';
104 |       }
105 | 
106 |       sslRequest
107 |         .get(config.auth.url + this.query)
108 |         .end((err, res) => {
109 |           try {
110 |             if (!res.ok) {
111 |               const errorMessages = utils.extractErrorMessages(res).join('\n');
112 |               console.log(errorMessages);
113 |               return callback(errorMessages);
114 |             }
115 |           } catch(e) {
116 |             if (err && err.message) {
117 |               return callback(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
118 |             }
119 |             return callback(e);
120 |           }
121 | 
122 |           callback(null, res.body.projects);
123 |       });
124 |     },
125 |     askIssueType: function (type, callback) {
126 |       var that = this,
127 |         issueTypeArray = create.projectMeta.issuetypes;
128 |       that.ask('Select issue type: ', function (issueType) {
129 |         callback(issueType);
130 |       }, false, issueTypeArray, type);
131 |     },
132 |     askRequired: function (eachField, eachFieldKey, defaultAnswer, scb) {
133 |       var that = this;
134 | 
135 |       if (!eachField.required && !(config.default_create && config.default_create['__always_ask'] && config.default_create['__always_ask'].fields && config.default_create['__always_ask'].fields[eachFieldKey])) {
136 |         return scb();
137 |       }
138 | 
139 |       var question = (eachField.allowedValues ? 'Select ' : 'Enter ') + eachField.name + ' : ';
140 |       that.ask(question, function (answer) {
141 |         if (answer) {
142 |           //supplying answer by field type
143 |           if (eachField.schema.type === 'array') {
144 |             if (eachField.schema.items !== 'string') {
145 |               create.answers.fields[eachFieldKey] = [{
146 |                 id: answer
147 |               }];
148 |             } else {
149 |               answer = answer.split(',');
150 |               create.answers.fields[eachFieldKey] = answer;
151 |             }
152 |           } else if (eachField.schema.type === 'string') {
153 |             create.answers.fields[eachFieldKey] = answer;
154 |           } else {
155 |             create.answers.fields[eachFieldKey] = {
156 |               id: answer
157 |             };
158 |           }
159 | 
160 |           return scb();
161 |         } else {
162 |           return create.askRequired(eachField, eachFieldKey, defaultAnswer, scb);
163 |         }
164 |       }, false, eachField.allowedValues, defaultAnswer);
165 |     },
166 |     saveIssue: function (options, cb) {
167 |       this.query = 'rest/api/2/issue';
168 |       const post_url = config.auth.url + this.query; //create.answers.fields.reporter['name'] = create.answers.fields.reporter['id'];
169 | 
170 |       if (create.answers.fields.reporter && 
171 |         !create.answers.fields.reporter['name'] &&
172 |         create.answers.fields.reporter['id']) {
173 |         create.answers.fields.reporter['name'] = create.answers.fields.reporter['id'];
174 |       }
175 |       const body = JSON.stringify(create.answers);
176 | 
177 |       if (options.verbose) {
178 |         console.log(create.answers);
179 |         console.log(post_url);
180 |         console.log(body);
181 |       }
182 | 
183 |       sslRequest.post(post_url)
184 |         .send(body)
185 |         .end((err, res) => {
186 |           try {
187 |             if (!res.ok) {
188 |               if (options.verbose) {
189 |                 console.log(res);
190 |               }
191 |               const errorMessages = utils.extractErrorMessages(res).join('\n');
192 |               return cb(errorMessages)
193 |             }
194 |           } catch(e) {
195 |             if (err && err.message) {
196 |               return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
197 |             }
198 |             return cb(e);
199 |           }
200 | 
201 |           if (options.verbose) {
202 |             console.log(res);
203 |           }
204 | 
205 |           console.log('Issue ' + res.body.key + ' created successfully!');
206 |           console.log('Open ' + utils.url.resolve(config.auth.url, 'browse/' + res.body.key));
207 |           return cb();
208 |         });
209 |     },
210 |     create: function (options, cb) {
211 |       // check if input config key given eg. payoutmdo
212 |       // if given then set the default values from config.json for payoutmdo
213 |       // prompt the input for other required:true fields
214 |       //
215 |       var that = this;
216 |       async.waterfall([// get project
217 |         function (wcb) {
218 |           create.getMeta(null, function (err, meta) {
219 |             if (err) {
220 |               return wcb(err);
221 |             }
222 | 
223 |             create.projects = meta;
224 |             return wcb(null, options);
225 |           });
226 |         }, function (options, wcb) {
227 |           // verify the project
228 |           if (options.key && config.default_create && config.default_create[options.key] && config.default_create[options.key].project) {
229 |             if (!options.project && config.default_create[options.key].project) {
230 |               options.project = config.default_create[options.key].project;
231 |             }
232 |           }
233 | 
234 |           create.askProject(options.project, function (projectId, index, projectKey) {
235 |             options.projectId = projectId;
236 |             options.projectIndex = index;
237 |             options.project = projectKey;
238 |             create.answers.fields.project = {
239 |               id: projectId
240 |             };
241 |             return wcb(null, options);
242 |           });
243 |         }, function (options, wcb) {
244 |           create.getMeta(options.project, function (err, meta) {
245 |             // call meta for this project https://jira.mypaytm.com/rest/api/2/issue/createmeta?projectKeys=MDO&expand=projects.issuetypes.fields&
246 |             if (err) {
247 |               return wcb(err);
248 |             }
249 | 
250 |             meta.forEach(function (eachProjectMeta) {
251 |               if (eachProjectMeta.id == options.projectId) {
252 |                 create.projectMeta = eachProjectMeta;
253 |               }
254 |             });
255 | 
256 |             if (!create.projectMeta) {
257 |               return wcb('project meta not found');
258 |             }
259 | 
260 |             return wcb(null, options);
261 |           });
262 |         }, function (options, wcb) {
263 |           // parse command line fields if they where passed in
264 |           if(options.field) {
265 |             if(options.verbose) {
266 |               console.log(options.field);
267 |             }
268 | 
269 |             create.answers.fields = {...create.answers.fields, ...options.field};
270 |           }
271 | 
272 |           return wcb(null, options)
273 |         }, function (options, wcb) {
274 |           //using default from config
275 |           // get issueType
276 |           if (options.key && config.default_create && config.default_create[options.key] && config.default_create[options.key].issueType) {
277 |             if (!options.type && config.default_create[options.key].issueType) {
278 |               options.type = config.default_create[options.key].issueType;
279 |             }
280 |           }
281 | 
282 |           create.askIssueType(options.type, function (issueType) {
283 |             create.answers.fields.issuetype = {
284 |               id: issueType
285 |             };
286 |             options.type = issueType;
287 |             create.projectMeta.issuetypes.forEach(function (eachIssueType) {
288 |               if (eachIssueType.id == issueType) {
289 |                 create.issueType = eachIssueType;
290 |               }
291 |             });
292 | 
293 |             if (!create.issueType) {
294 |               return wcb(new Error('invalid issue type'));
295 |             }
296 | 
297 |             return wcb(null, options);
298 |           });
299 |         }, function (options, wcb) {
300 |           //ask for required fields
301 |           // get required:true fields from meta
302 |           if(options.verbose) {
303 |             console.log(options);
304 |           }
305 | 
306 |           async.eachSeries(Object.keys(create.issueType.fields), function (eachFieldKey, scb) {
307 |             var eachField = create.issueType.fields[eachFieldKey]; //if only 1 allowed value then take it as answer  and dont prompt the user
308 | 
309 |             var defaultAnswer;
310 | 
311 |             if (eachField.allowedValues && eachField.allowedValues.length == 1) {
312 |               defaultAnswer = eachField.allowedValues[0].id;
313 |               return scb();
314 |             } //picking field config from config
315 | 
316 |             if (options.verbose) {
317 |               console.log({
318 |                 eachField: eachField
319 |               });
320 |               console.log({
321 |                 eachFieldKey: eachFieldKey
322 |               });
323 |             }
324 | 
325 |             if (options.key && config.default_create && config.default_create[options.key] && config.default_create[options.key].default) {
326 |               if (config.default_create[options.key].default[eachFieldKey]) {
327 |                 create.answers.fields[eachFieldKey] = config.default_create[options.key].default[eachFieldKey];
328 |                 return scb();
329 |               }
330 |             }
331 | 
332 |             if (options[eachFieldKey]) {
333 |               if (!create.answers.fields[eachFieldKey]) {
334 |                 // only set answer if it hasn't been set already
335 |                 create.answers.fields[eachFieldKey] = options[eachFieldKey];
336 |               }
337 |               return scb();
338 |             }
339 | 
340 |             return create.askRequired(eachField, eachFieldKey, defaultAnswer, scb);
341 |           }, function () {
342 |             return wcb(null, options);
343 |           });
344 |         }, function (options, wcb) {
345 |           create.saveIssue(options, wcb);
346 |         }], function (err) {
347 |         return cb(err);
348 |       });
349 |     }
350 |   };
351 |   return create;
352 | }();
353 | 


--------------------------------------------------------------------------------
/lib/jira/release.js:
--------------------------------------------------------------------------------
 1 | // https://docs.atlassian.com/software/jira/docs/api/REST/8.1.0/
 2 | module.exports = function () {
 3 |   var sslRequest = require('../../lib/ssl_request');;
 4 | 
 5 |   var moment = require('moment');
 6 | 
 7 |   var config = require('../../lib/config');
 8 | 
 9 |   var release = {
10 |     query: null,
11 |     table: null,
12 |     create: function (version, options, cb) {
13 |       this.query = 'rest/api/2/version';
14 |       var releaseDate = moment().format('YYYY-MM-DD');
15 |       sslRequest.post(config.auth.url + this.query).send({
16 |         'name': version,
17 |         'project': options.project,
18 |         'released': options.released,
19 |         'releaseDate': releaseDate,
20 |         'description': options.description
21 |       }).end((err, res) => {
22 |         try {
23 |           if (!res.ok) {
24 |             return console.log((res.body.errorMessages || [res.error]).join('\n'));
25 |           }
26 |         } catch(e) {
27 |           if (err && err.message) {
28 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
29 |           }
30 |           return cb(e);
31 |         }
32 | 
33 |         console.log('ReleaseId=' + res.body.id);
34 |         console.log('ProjectId=' + res.body.projectId);
35 |         return;
36 |       });
37 |     }
38 |   };
39 |   return release;
40 | }();
41 | 


--------------------------------------------------------------------------------
/lib/jira/send.js:
--------------------------------------------------------------------------------
 1 | /*global requirejs,console,define,fs*/
 2 | module.exports = function () {
 3 |   var sslRequest = require('../../lib/ssl_request');;
 4 | 
 5 |   var config = require('../../lib/config');
 6 | 
 7 |   var report = {
 8 |     query: null,
 9 |     table: null,
10 |     send: function (options) {
11 | 
12 |       _ = require("underscore");
13 | 
14 |       var fs = require("fs");
15 |       sslRequest.post(config.auth.url + 'secure/ReleaseNote.jspa')
16 |       .query({ projectId: options.projectId })
17 |       .query({ version: options.version })
18 |       .end((error, response) => {
19 |         if (error) throw new Error(error);
20 |         cheerio = require("cheerio");
21 |         var $ = cheerio.load(response.body);
22 |         editcopy = $('textarea#editcopy').text();
23 | 
24 |         const nodemailer = require('nodemailer');
25 | 
26 |         let transporter = nodemailer.createTransport({
27 |           service: 'gmail',
28 |           auth: {
29 |             user: config.auth.user,
30 |             pass: options.password
31 |           }
32 |         });
33 |         templateContent = fs.readFileSync(options.template, encoding = "utf8");
34 |         var data = {
35 |           release_version: options.name,
36 |           link: config.auth.url + 'projects/' + options.project_prefix + '/versions/' + options.version,
37 |           report: editcopy
38 |         };
39 |         _.templateSettings = {
40 |           interpolate: /\{\{(.+?)\}\}/g
41 |         };
42 |         getHTML = _.template(templateContent);
43 |         html_body = getHTML(data);
44 | 
45 |         async function send_it() {
46 |           let info = await transporter.sendMail({
47 |             from: config.auth.user,
48 |             to: options.to,
49 |             cc: options.cc,
50 |             subject: options.subject,
51 |             html: html_body
52 |           });
53 |           console.log('Message sent: %s', info.messageId);
54 |         }
55 | 
56 |         send_it();
57 |       });
58 |     }
59 |   };
60 |   return report;
61 | }();


--------------------------------------------------------------------------------
/lib/jira/sprint.js:
--------------------------------------------------------------------------------
  1 | /*global requirejs,console,define,fs*/
  2 | module.exports = function () {
  3 |   var program = require('commander');
  4 | 
  5 |   var sslRequest = require('../../lib/ssl_request');;
  6 | 
  7 |   var Table = require('cli-table');
  8 | 
  9 |   var config = require('../../lib/config');
 10 | 
 11 |   var getRapidBoardID = function getRapidBoardID(rapidBoardID, cb) {
 12 |     if (typeof rapidBoardID !== 'string') {
 13 |       rapidBoardID = undefined;
 14 |     }
 15 | 
 16 |     sslRequest.get(config.auth.url + 'rest/greenhopper/latest/rapidviews/list').end((err, res) => {
 17 |       try {
 18 |         if (!res.ok) {
 19 |           console.log('Error getting rapid boards. HTTP Status Code: ' + res.status);
 20 |           return;
 21 |         }
 22 |       } catch(e) {
 23 |         if (err && err.message) {
 24 |           return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
 25 |         }
 26 |         return cb(e);
 27 |       }
 28 | 
 29 |       displayRapidBoards(rapidBoardID, res.body, cb);
 30 |     });
 31 |   };
 32 | 
 33 |   var displayRapidBoards = function displayRapidBoards(rapidBoardID, data, cb) {
 34 |     var table = new Table({
 35 |       head: ['Key', 'Name']
 36 |     });
 37 |     var pushTable = [];
 38 | 
 39 |     for (i = 0; i < data.views.length; i++) {
 40 |       var item = data.views[i];
 41 | 
 42 |       if (rapidBoardID !== undefined) {
 43 |         if (item.name.toLowerCase() == rapidBoardID.toLowerCase()) {
 44 |           pushTable = [[item.id, item.name]];
 45 |           break;
 46 |         }
 47 | 
 48 |         if (item.name.toLowerCase().indexOf(rapidBoardID.toLowerCase()) === -1) {
 49 |           continue;
 50 |         }
 51 |       }
 52 | 
 53 |       pushTable.push([item.id, item.name]);
 54 |     }
 55 | 
 56 |     table.push.apply(table, pushTable);
 57 | 
 58 |     if (table.length === 0) {
 59 |       if (rapidBoardID === undefined) {
 60 |         console.log('No rapid boards found in your Jira instance');
 61 |       } else {
 62 |         console.log('No rapid boards found matching term in your Jira instance: ' + rapidBoardID);
 63 |       }
 64 |     } else if (table.length === 1) {
 65 |       console.log('****Found Rapid Board: ' + table[0][1]);
 66 |       cb(table[0][0]);
 67 |     } else {
 68 |       console.log('\nMatching Rapid Boards:');
 69 |       console.log('=========================================\n');
 70 |       console.log(table.toString());
 71 |     }
 72 |   };
 73 | 
 74 |   var getSprintID = function getSprintID(rapidBoardID, sprintID, cb) {
 75 |     if (typeof sprintID !== 'string') {
 76 |       sprintID = undefined;
 77 |     }
 78 | 
 79 |     sslRequest.get(config.auth.url + 'rest/greenhopper/latest/sprintquery/' + rapidBoardID).end((err, res) => {
 80 |       try {
 81 |         if (!res.ok) {
 82 |           console.log('Error getting sprints. HTTP Status Code: ' + res.status);
 83 |           return;
 84 |         }
 85 |       } catch(e) {
 86 |         if (err && err.message) {
 87 |           return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
 88 |         }
 89 |         return cb(e);
 90 |       }
 91 | 
 92 |       displaySprints(rapidBoardID, sprintID, res.body, cb);
 93 |     });
 94 |   };
 95 | 
 96 |   var displaySprints = function displaySprints(rapidBoardID, sprintID, data, cb) {
 97 |     var table = new Table({
 98 |       head: ['Key', 'Name', 'Status']
 99 |     });
100 |     var pushTable = [];
101 | 
102 |     for (i = 0; i < data.sprints.length; i++) {
103 |       var item = data.sprints[i];
104 | 
105 |       if (sprintID !== undefined) {
106 |         if (item.name.toLowerCase() == sprintID.toLowerCase()) {
107 |           pushTable = [[item.id, item.name, item.state]];
108 |           break;
109 |         }
110 | 
111 |         if (item.state !== 'ACTIVE') {
112 |           continue;
113 |         }
114 | 
115 |         if (item.name.toLowerCase().indexOf(sprintID.toLowerCase()) === -1) {
116 |           continue;
117 |         }
118 |       }
119 | 
120 |       pushTable.push([item.id, item.name, item.state]);
121 |     }
122 | 
123 |     table.push.apply(table, pushTable);
124 | 
125 |     if (table.length == 0) {
126 |       if (sprintID === undefined) {
127 |         console.log('No sprints found in rapid board ' + rapidBoardID);
128 |       } else {
129 |         console.log('No sprints found matching term in rapid board ' + rapidBoardID + ': ' + sprintID);
130 |       }
131 |     } else if (table.length === 1) {
132 |       console.log('****Found Sprint: ' + table[0][1]);
133 |       cb(table[0][0]);
134 |     } else {
135 |       console.log('\nMatching Sprints:');
136 |       console.log('=========================================\n');
137 |       console.log(table.toString());
138 |       return cb(pushTable[pushTable.length - 1][0], pushTable); //picks the last sprint
139 |     }
140 |   };
141 | 
142 |   var getSprintIssues = function getSprintIssues(rapidBoardID, sprintID, cb) {
143 |     var qParams = 'rapidViewId=' + rapidBoardID;
144 | 
145 |     if (sprintID) {
146 |       qParams += '&sprintId=' + sprintID;
147 |     }
148 | 
149 |     sslRequest.get(config.auth.url + 'rest/greenhopper/latest/rapid/charts/sprintreport?' + qParams).end((err, res) => {
150 |       try {
151 |         if (!res.ok) {
152 |           console.log('Error getting sprint data. HTTP Status Code: ' + res.status);
153 |           console.dir(res.body);
154 |           return;
155 |         }
156 |       } catch(e) {
157 |         if (err && err.message) {
158 |           return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
159 |         }
160 |         return cb(e);
161 |       }
162 | 
163 |       cb(res.body);
164 |     });
165 |   };
166 | 
167 |   var displaySprintIssues = function displaySprintIssues(rapidBoardID, sprintID, data) {
168 |     var sprint = new Table({
169 |       head: ['Key', 'Name', 'Status', 'Start Date', 'End Date']
170 |     });
171 |     var completed = new Table({
172 |       head: ['Key', 'Type', 'Assignee', 'Priority', 'Status', 'Summary']
173 |     });
174 |     var incompleted = new Table({
175 |       head: ['Key', 'Type', 'Assignee', 'Priority', 'Status', 'Summary']
176 |     });
177 |     var punted = new Table({
178 |       head: ['Key', 'Type', 'Assignee', 'Priority', 'Status', 'Summary']
179 |     });
180 | 
181 |     var pushIssues = function pushIssues(issues, table) {
182 |       if (!issues) return;
183 |       issues.forEach(function (issue) {
184 |         var priority = issue.priorityName || 'Unknown',
185 |           summary = issue.summary.length > 45 ? issue.summary.substr(0, 42) + '...' : issue.summary,
186 |           status = issue.statusName || 'Unknown',
187 |           assignee = issue.assignee || 'None',
188 |           key = issue.key || 'Unknown',
189 |           type = issue.typeName || 'Unknown';
190 |         table.push([key, type, assignee, priority, status, summary]);
191 |       });
192 |     };
193 | 
194 |     pushIssues(data.contents.completedIssues, completed);
195 |     pushIssues(data.contents.issuesNotCompletedInCurrentSprint, incompleted);
196 |     pushIssues(data.contents.puntedIssues, punted);
197 |     sprint.push([data.sprint.id, data.sprint.name, data.sprint.state, data.sprint.startDate, data.sprint.endDate]);
198 | 
199 |     var displayTable = function displayTable(msg, table) {
200 |       if (table.length > 0) {
201 |         console.log(msg);
202 |         console.log(table.toString());
203 |         console.log('\n==============================================================\n');
204 |       }
205 |     };
206 | 
207 |     console.log('\n==============================================================');
208 |     console.log('====                        SPRINT                        ====');
209 |     console.log('==============================================================\n');
210 |     displayTable('Sprint:', sprint);
211 |     displayTable('Completed Issues:', completed);
212 |     displayTable('Punted Issues:', punted);
213 |     displayTable('Incompleted Issues:', incompleted);
214 |   };
215 | 
216 |   return function sprint(userRapidBoardID, userSprintID, cb) {
217 |     getRapidBoardID(userRapidBoardID, function (rapidBoardID) {
218 |       getSprintID(rapidBoardID, userSprintID, function (sprintID, allSprints) {
219 |         getSprintIssues(rapidBoardID, sprintID, function (data) {
220 |           if (cb) {
221 |             displaySprintIssues(rapidBoardID, sprintID, data);
222 |             return cb(allSprints);
223 |           } else {
224 |             displaySprintIssues(rapidBoardID, sprintID, data);
225 |           }
226 |         });
227 |       });
228 |     });
229 |   };
230 | }();
231 | 


--------------------------------------------------------------------------------
/lib/jira/transitions.js:
--------------------------------------------------------------------------------
  1 | /*global requirejs,console,define,fs*/
  2 | module.exports = function () {
  3 |   var sslRequest = require('../../lib/ssl_request');;
  4 | 
  5 |   var Table = require('cli-table');
  6 | 
  7 |   var config = require('../../lib/config');
  8 | 
  9 |   const promptly = require('promptly');
 10 | 
 11 |   var transitions = {
 12 |     query: null,
 13 |     transitions: null,
 14 |     transitionID: null,
 15 |     ask: function (question, callback, yesno, values, answer) {
 16 |       var that = this,
 17 |         issueTypes = [],
 18 |         i = 0;
 19 | 
 20 |       if (answer || answer === false) {
 21 |         return callback(answer);
 22 |       }
 23 | 
 24 |       if (values && values.length > 0) {
 25 |         for (i; i < values.length; i++) {
 26 |           if (that.isSubTask) {
 27 |             if (values[i].subtask !== undefined) {
 28 |               if (values[i].subtask) {
 29 |                 issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 30 |               }
 31 |             } else {
 32 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 33 |             }
 34 |           } else {
 35 |             if (!values[i].subtask) {
 36 |               issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
 37 |             }
 38 |           }
 39 |         }
 40 | 
 41 |         console.log(issueTypes.join('\n'));
 42 |       }
 43 | 
 44 |       valueArray = values.map(function (value) {
 45 |         return value.id;
 46 |       });
 47 |       promptly
 48 |         .prompt(question)
 49 |         .then(answer => {
 50 |           if (answer.length > 0) {
 51 |             if (valueArray.indexOf(answer) >= 0) {
 52 |               callback(answer);
 53 |             } else {
 54 |               that.ask(question, callback, yesno, values);
 55 |             }
 56 |           } else {
 57 |             if (yesno) {
 58 |               callback(false);
 59 |             } else {
 60 |               that.ask(question, callback);
 61 |             }
 62 |           }
 63 |         })
 64 |         .catch(e => {
 65 |           if(e && e.message === 'canceled') {
 66 |             console.log('\nInput cancelled');
 67 |           } else {
 68 |             console.log('\nError: ' + e.toString());
 69 |           }
 70 |         });
 71 |     },
 72 |     doTransition: function (issue, transitionID, resolutionID, cb) {
 73 |       var that = this;
 74 | 
 75 |       if (typeof resolutionID === 'function') {
 76 |         cb = resolutionID;
 77 |         resolutionID = null;
 78 |       }
 79 | 
 80 |       this.query = 'rest/api/2/issue/' + issue + '/transitions';
 81 |       var requestBody = {
 82 |         transition: {
 83 |           id: transitionID
 84 |         }
 85 |       };
 86 | 
 87 |       if (resolutionID && config.options['jira_done']['check_resolution']) {
 88 |         requestBody.fields = {
 89 |           resolution: {
 90 |             id: resolutionID
 91 |           }
 92 |         };
 93 |       }
 94 | 
 95 |       sslRequest.post(config.auth.url + this.query).send(requestBody).end((err, res) => {
 96 |         try {
 97 |           if (!res.ok) {
 98 |             cb((res.body.errorMessages || [res.error]).join('\n'));
 99 |           }
100 |         } catch(e) {
101 |           if (err && err.message) {
102 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
103 |           }
104 |           return cb(e);
105 |         }
106 | 
107 |         if (cb) {
108 |           cb();
109 |         }
110 |       });
111 |     },
112 |     getTransitions: function (issue, cb) {
113 |       this.query = 'rest/api/2/issue/' + issue + '/transitions';
114 |       sslRequest.get(config.auth.url + this.query).end((err, res) => {
115 |         try {
116 |           if (!res.ok) {
117 |             debugger;
118 |             return cb(new Error(res.body.errorMessages.join('\n')));
119 |           }
120 |         } catch(e) {
121 |           if (err && err.message) {
122 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
123 |           }
124 |           return cb(e);
125 |         }
126 | 
127 |         var transitions = res.body.transitions || [];
128 |         return cb(null, transitions);
129 |       });
130 |     },
131 |     makeTransition: function (issue, cb) {
132 |       transitions.getTransitions(issue, function (err, transitionsAvailable) {
133 |         if (err) {
134 |           return cb(err);
135 |         }
136 | 
137 |         transitions.ask('Enter transition ', function (answer) {
138 |           transitions.doTransition(issue, answer, function (err) {
139 |             if (err) {
140 |               return cb(err);
141 |             }
142 | 
143 |             console.log('marked issue with transition ' + answer);
144 |             return cb();
145 |           });
146 |         }, null, transitionsAvailable);
147 |       });
148 |     },
149 |     getTransitionCode: function (issue, transitionName, cb) {
150 |       var that = this,
151 |         i = 0;
152 |       transitions.getTransitions(issue, function (err, allTransitions) {
153 |         if (err) {
154 |           return cb(err);
155 |         }
156 | 
157 |         allTransitions.some(function (transition) {
158 |           if (transition.name === transitionName) {
159 |             that.transitionID = transition.id;
160 |           } else if (transition.to.name === transitionName) {
161 |             that.transitionID = transition.id;
162 |           }
163 |         });
164 | 
165 |         if (!that.transitionID) {
166 |           console.log('Issue already ' + transitionName + ' or bad transition.');
167 | 
168 |           if (allTransitions) {
169 |             console.log('Available Transitions');
170 |             var table = new Table({
171 |               head: ['Key', 'Name']
172 |             });
173 |             allTransitions.forEach(function (item) {
174 |               table.push([item.id, item.name]);
175 |             });
176 |             console.log(table.toString());
177 |           }
178 | 
179 |           return;
180 |         } else {
181 |           cb(that.transitionID);
182 |         }
183 |       });
184 |     },
185 |     getResolutionCode: function (resolutionName, callback) {
186 |       var that = this,
187 |         i = 0;
188 |       this.query = 'rest/api/2/resolution';
189 |       sslRequest.get(config.auth.url + this.query).end((err, res) => {
190 |         try {
191 |           if (!res.ok) {
192 |             return console.log(res.body.errorMessages.join('\n'));
193 |           }
194 |         } catch(e) {
195 |           if (err && err.message) {
196 |             return callback(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
197 |           }
198 |           return callback(e);
199 |         }
200 | 
201 |         var resolutions = res.body,
202 |           resolutionData; // when a specific resolution is informed by command line.
203 | 
204 |         if (resolutionName && resolutionName !== '') {
205 |           resolutions.forEach(function (resolution) {
206 |             if (resolution.name == resolutionName) {
207 |               resolutionData = resolution;
208 |             }
209 |           });
210 |         } // default is always first
211 |         else if (!resolutionName && resolutions.length > 0) {
212 |           resolutionData = resolutions[0];
213 |         }
214 | 
215 |         if (resolutionData) {
216 |           return callback(resolutionData.id);
217 |         } else {
218 |           console.log('Resolution Not Found!\n');
219 |           console.log('Available Resolutions');
220 |           var table = new Table({
221 |             head: ['Key', 'Name', 'Description']
222 |           });
223 |           resolutions.forEach(function (item) {
224 |             table.push([item.id, item.name, item.description]);
225 |           });
226 |           console.log(table.toString());
227 |           console.log('You can change that behaviour by editing ~/.jira/config.json');
228 |           return;
229 |         }
230 |       });
231 |     },
232 |     start: function (issue, cb) {
233 |       var that = this;
234 |       this.transitionName = config.options['jira_start']['status'];
235 |       this.getTransitionCode(issue, that.transitionName, function (transitionID) {
236 |         that.doTransition(issue, transitionID, function (err) {
237 |           console.log('Issue [' + issue + '] moved to ' + that.transitionName);
238 |           cb(err);
239 |         });
240 |       });
241 |     },
242 |     stop: function (issue, cb) {
243 |       var that = this;
244 |       this.transitionName = config.options['jira_stop']['status'];
245 |       this.getTransitionCode(issue, that.transitionName, function (transitionID) {
246 |         that.doTransition(issue, transitionID, function (err) {
247 |           console.log('Issue [' + issue + '] moved to ' + that.transitionName);
248 |           cb(err);
249 |         });
250 |       });
251 |     },
252 |     review: function (issue, cb) {
253 |       var that = this;
254 |       this.transitionName = config.options['jira_review']['status'];
255 |       this.getTransitionCode(issue, that.transitionName, function (transitionID) {
256 |         that.doTransition(issue, transitionID, function (err) {
257 |           console.log('Issue [' + issue + '] moved to ' + that.transitionName);
258 |           cb(err);
259 |         });
260 |       });
261 |     },
262 |     done: function (issue, resolution, cb) {
263 |       var that = this;
264 |       this.transitionName = config.options['jira_done']['status'];
265 |       this.resolutionName = resolution;
266 |       this.getResolutionCode(this.resolutionName, function (resolutionID) {
267 |         that.getTransitionCode(issue, that.transitionName, function (transitionID) {
268 |           that.doTransition(issue, transitionID, resolutionID, function (err) {
269 |             console.log('Issue [' + issue + '] moved to ' + that.transitionName);
270 |             cb(err);
271 |           });
272 |         });
273 |       });
274 |     },
275 |     invalid: function (issue, resolution, cb) {
276 |       var that = this;
277 |       this.transitionName = config.options['jira_invalid']['status'];
278 |       this.resolutionName = resolution;
279 |       this.getResolutionCode(this.resolutionName, function (resolutionID) {
280 |         that.getTransitionCode(issue, that.transitionName, function (transitionID) {
281 |           that.doTransition(issue, transitionID, resolutionID, function (err) {
282 |             console.log('Issue [' + issue + '] moved to ' + that.transitionName);
283 |             cb(err);
284 |           });
285 |         });
286 |       });
287 |     }
288 |   };
289 |   return transitions;
290 | }();
291 | 


--------------------------------------------------------------------------------
/lib/jira/watch.js:
--------------------------------------------------------------------------------
 1 | /*global requirejs,console,define,fs*/
 2 | module.exports = function () {
 3 |   var sslRequest = require('../../lib/ssl_request');;
 4 | 
 5 |   var config = require('../../lib/config');
 6 | 
 7 |   var assign = {
 8 |     query: null,
 9 |     table: null,
10 |     to: function (ticket, assignee, cb) {
11 |       this.query = 'rest/api/2/issue/' + ticket + '/watchers';
12 |       sslRequest.post(config.auth.url + this.query).send('"' + assignee + '"').end((err, res) => {
13 |         try {
14 |           if (!res.ok) {
15 |             return console.log((res.body.errorMessages || [res.error]).join('\n'));
16 |           }
17 |         } catch(e) {
18 |           if (err && err.message) {
19 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
20 |           }
21 |           return cb(e);
22 |         }
23 | 
24 |         return console.log('Added ' + assignee + ' as watcher to [' + ticket + '] ' + '.');
25 |       });
26 |     },
27 |     me: function (ticket, cb) {
28 |       this.to(ticket, config.auth.user, cb);
29 |     }
30 |   };
31 |   return assign;
32 | }();
33 | 


--------------------------------------------------------------------------------
/lib/jira/worklog.js:
--------------------------------------------------------------------------------
 1 | /*global requirejs,console,define,fs*/
 2 | module.exports = function () {
 3 |   var program = require('commander');
 4 | 
 5 |   var sslRequest = require('../../lib/ssl_request');;
 6 | 
 7 |   var Table = require('cli-table');
 8 | 
 9 |   var moment = require('moment');
10 | 
11 |   var config = require('../../lib/config');
12 | 
13 |   var worklog = {
14 |     add: function (issue, timeSpent, comment, startedAt, cb) {
15 |       var url = 'rest/api/latest/issue/' + issue + '/worklog';
16 |       var formattedStart = moment(startedAt).format('YYYY-MM-DD[T]HH:mm:ss.SSSZZ');
17 |       sslRequest.post(config.auth.url + url).send({
18 |         comment: comment,
19 |         timeSpent: timeSpent,
20 |         started: formattedStart
21 |       }).end((err, res) => {
22 |         try {
23 |           if (!res.ok) {
24 |             return console.log((res.body.errorMessages || [res.error]).join('\n'));
25 |           }
26 |         } catch(e) {
27 |           if (err && err.message) {
28 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
29 |           }
30 |           return cb(e);
31 |         }
32 | 
33 |         return console.log('Worklog to issue [' + issue + '] was added!.');
34 |       });
35 |     },
36 |     show: function (issue, cb) {
37 |       var url = 'rest/api/latest/issue/' + issue + '/worklog';
38 |       sslRequest.get(config.auth.url + url).end((err, res) => {
39 |         try {
40 |           if (!res.ok) {
41 |             return console.log(res.body.errorMessages.join('\n'));
42 |           }
43 |         } catch(e) {
44 |           if (err && err.message) {
45 |             return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
46 |           }
47 |           return cb(e);
48 |         }
49 | 
50 |         if (res.body.total == 0) {
51 |           console.log('No work yet logged');
52 |           return;
53 |         }
54 | 
55 |         var tbl = new Table({
56 |             head: ['Date', 'Author', 'Time Spent', 'Comment']
57 |           }),
58 |           worklogs = res.body.worklogs;
59 | 
60 |         for (i = 0; i < worklogs.length; i++) {
61 |           var startDate = worklogs[i].created,
62 |             author = worklogs[i].author.displayName,
63 |             timeSpent = worklogs[i].timeSpent,
64 |             comment = worklogs[i].comment || '';
65 | 
66 |           if (comment.length > 50) {
67 |             comment = comment.substr(0, 47) + '...';
68 |           }
69 | 
70 |           tbl.push([startDate, //TODO format date
71 |             author, timeSpent, comment]);
72 |         }
73 | 
74 |         console.log(tbl.toString());
75 |       });
76 |     }
77 |   };
78 |   return worklog;
79 | }();
80 | 


--------------------------------------------------------------------------------
/lib/prompt.js:
--------------------------------------------------------------------------------
 1 | /*global requirejs,console,define,fs*/
 2 | module.exports = function () {
 3 |   var readline = require('readline');
 4 | 
 5 |   var sslRequest = require('../../lib/ssl_request');;
 6 | 
 7 |   var config = require('./config');
 8 | 
 9 |   var getUserCompletions = function getUserCompletions(line, word, options, cb) {
10 |     var userOptions = options && options.user ? options.user : {},
11 |       enabled = userOptions.enabled !== undefined ? userOptions.enabled : false,
12 |       forMention = userOptions ? userOptions.forMention : false,
13 |       isUserComplete = word && forMention ? word.indexOf('[~') === 0 : true,
14 |       queryWord = forMention && isUserComplete ? word.slice(2) : word;
15 | 
16 |     if (!enabled || !isUserComplete || !queryWord) {
17 |       return cb([]);
18 |     }
19 | 
20 |     result = !queryWord ? null : sslRequest.get(config.auth.url + 'rest/api/2/user/search?username=' + queryWord).end((err, res) => {
21 |       try {
22 |         if (!res.ok) {
23 |           return console.log(res.body.errorMessages.join('\n'));
24 |         }
25 |       } catch(e) {
26 |         if (err && err.message) {
27 |           return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
28 |         }
29 |         return cb(e);
30 |       }
31 | 
32 |       var hits = res.body.filter(function (user) {
33 |         return user.name.indexOf(queryWord) == 0;
34 |       });
35 |       hits = hits.map(function (user) {
36 |         return user.name;
37 |       });
38 |       var exact = hits.filter(function (user) {
39 |         return user == queryWord;
40 |       });
41 |       hits = exact.length === 1 ? exact : hits;
42 | 
43 |       if (forMention) {
44 |         hits = hits.map(function (user) {
45 |           return '[~' + user + ']';
46 |         });
47 |       }
48 | 
49 |       cb(hits, word);
50 |     });
51 |   };
52 | 
53 |   var getCompletions = function getCompletions(line, word, options, cb) {
54 |     getUserCompletions(line, word, options, function userCompletionHits(userHits, line) {
55 |       cb(null, [userHits, line]);
56 |     });
57 |   };
58 | 
59 |   var getCompleter = function getCompleter(options) {
60 |     var completer = function completer(line, cb) {
61 |       var words = line ? line.split(/\s+/) : [],
62 |         word = words.length > 0 ? words[words.length - 1] : '';
63 | 
64 |       if (!word) {
65 |         cb([[], line]);
66 |       }
67 | 
68 |       getCompletions(line, word, options, cb);
69 |     };
70 | 
71 |     return completer;
72 |   };
73 | 
74 |   return function (question, cb, options) {
75 |     var options = options || options,
76 |       rl = readline.createInterface({
77 |         input: process.stdin,
78 |         output: process.stdout,
79 |         completer: getCompleter(options)
80 |       });
81 |     rl.question(question, function (answer) {
82 |       rl.close();
83 |       cb(answer);
84 |     });
85 |   };
86 | }();
87 | 


--------------------------------------------------------------------------------
/lib/settings.js:
--------------------------------------------------------------------------------
 1 | module.exports = (() => {
 2 |   var path = require('path');
 3 | 
 4 |   const home_directory = process.cwd();
 5 |   const config = {
 6 |     directory_name: '.jira-cli',
 7 |     config_file_name: 'config.json',
 8 |     certificate_file_name: 'jira.crt'
 9 |   };
10 | 
11 |   function _getConfigFilePath() {
12 |     return process.env['JIRA_CONFIG'] || path.join(_getConfigDirectory(), config.config_file_name);
13 |   }
14 | 
15 |   function _getCertificateFilePath() {
16 |     return process.env['JIRA_CERT'] || path.join(_getConfigDirectory(), config.certificate_file_name);
17 |   }
18 | 
19 |   function _getConfigDirectory() {
20 |     return path.join(home_directory, config.directory_name);
21 |   }
22 | 
23 |   return {
24 |     getConfigFilePath: _getConfigFilePath,
25 |     getConfigDirectory: _getConfigDirectory,
26 |     getCertificateFilePath: _getCertificateFilePath
27 |   };
28 | })();
29 | 


--------------------------------------------------------------------------------
/lib/ssl_request.js:
--------------------------------------------------------------------------------
 1 | module.exports = (() => {
 2 |   let config = require('./config');
 3 |   let request = require('superagent');
 4 | 
 5 |   var _buildRequest = function (verb) {
 6 |     let base64AuthToken = Buffer.from(`${config.auth.user}:${config.auth.token}`).toString('base64');
 7 |     if (config.use_self_signed_certificate) {
 8 |       let ca = require('./ca');
 9 |       return argument => request[verb](argument)
10 |         .ca(ca)
11 |         .set('Content-Type', 'application/json')
12 |         .set('Authorization', 'Basic ' + base64AuthToken);
13 |     } else {
14 |       return argument => request[verb](argument)
15 |         .set('Content-Type', 'application/json')
16 |         .set('Authorization', 'Basic ' + base64AuthToken);
17 |     }
18 |   };
19 | 
20 |   return {
21 |     get: _buildRequest('get'),
22 |     post: _buildRequest('post'),
23 |     put: _buildRequest('put'),
24 |     delete: _buildRequest('delete')
25 |   };
26 | })();
27 | 


--------------------------------------------------------------------------------
/lib/utils.js:
--------------------------------------------------------------------------------
 1 | 
 2 | module.exports = (() => {
 3 |   const fs = require('fs');
 4 |   const _url = require('url');
 5 | 
 6 |   function _loadFromFile(path) {
 7 |     return fs.readFileSync(path, 'utf-8');
 8 |   }
 9 | 
10 |   function _isFileExists(path) {
11 |     return fs.existsSync(path);
12 |   }
13 | 
14 |   function _createDirectory(directory) {
15 |     if (!_isFileExists(directory)) {
16 |       fs.mkdir(directory, function (e) {
17 |         console.log(e);
18 |       });
19 |     }
20 |   }
21 | 
22 |   function _saveToFile(path, content) {
23 |     fs.writeFileSync(path, content);
24 |   }
25 | 
26 |   function _deleteDirectory(directoryPath) {
27 |     if (fs.existsSync(directoryPath)) {
28 |       fs.rmdirSync(directoryPath);
29 |     }
30 |   }
31 | 
32 |   function _deleteFile(pathTofile) {
33 |     if (_isFileExists(pathTofile)) fs.unlinkSync(pathTofile);
34 |   }
35 | 
36 |   function _extractErrorMessages (response) {
37 |     const { errors, messages, errorMessages } = typeof response === 'string' ? JSON.parse(response).body : response.body;
38 | 
39 |     function convertErrorsToArray (errors) {
40 |       if (!errors) {return [];}
41 | 
42 |       function formatErrorMessage (element) {
43 |         return `${element}: ${errors[element]}`;
44 |       }
45 | 
46 |       return Object.keys(errors).map(formatErrorMessage);
47 |     }
48 | 
49 |     return (messages && messages.length) ? messages : (errorMessages && errorMessages.length) ? errorMessages : convertErrorsToArray(errors);
50 |   }
51 | 
52 |   return {
53 |     url: _url,
54 |     extractErrorMessages: _extractErrorMessages,
55 |     isFileExists: _isFileExists,
56 |     loadFromFile: _loadFromFile,
57 |     deleteDirectory: _deleteDirectory,
58 |     deleteFile: _deleteFile,
59 |     saveToFile: _saveToFile,
60 |     createDirectory: _createDirectory
61 |   };
62 | })();
63 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "jira-cli",
 3 |   "description": "A JIRA Command Line Interface",
 4 |   "version": "2.7.0",
 5 |   "author": "Dan Shumaker <danpshumaker@gmail.com> (https://danshumaker.github.io/)",
 6 |   "contributors": [],
 7 |   "scripts": {
 8 |     "test": "jest",
 9 |     "test:e2e": "bin/tests.sh && exit 1",
10 |     "patch-release": "npm version patch && npm publish && git push --follow-tags",
11 |     "dev": "node bin/jira.js",
12 |     "start": "npm i -g && jira",
13 |     "clean:dev": "rimraf -rf ./.jira-cli",
14 |     "clean": "rimraf -rf ~/.jira-cli && npm uninstall jira-cli -g",
15 |     "lint": "eslint . --ext .js,.ts --ignore-path .gitignore",
16 |     "fix": "npm run lint -- --fix"
17 |   },
18 |   "dependencies": {
19 |     "@types/jest": "^25.2.3",
20 |     "alasql": "^1.7.3",
21 |     "async": "^2.6.3",
22 |     "cheerio": "^1.0.0-rc.3",
23 |     "cli-table": "^0.2.0",
24 |     "commander": "~2.20.1",
25 |     "dargs": "^5.1.0",
26 |     "fs": "0.0.1-security",
27 |     "jira-connector": "^3.1.0",
28 |     "lodash.set": "^4.3.2",
29 |     "moment": "^2.29.1",
30 |     "nodemailer": "^6.4.14",
31 |     "openurl": "^1.1.0",
32 |     "promptly": "^3.2.0",
33 |     "qs": "^6.9.4",
34 |     "superagent": "~5.3.1",
35 |     "underscore": "^1.11.0"
36 |   },
37 |   "engines": {
38 |     "node": ">= 4"
39 |   },
40 |   "keywords": [
41 |     "jira",
42 |     "api",
43 |     "client",
44 |     "command",
45 |     "cli",
46 |     "tool",
47 |     "command-line-junky"
48 |   ],
49 |   "license": "MIT",
50 |   "repository": {
51 |     "type": "git",
52 |     "url": "git://github.com/danshumaker/jira-cli.git"
53 |   },
54 |   "bin": {
55 |     "jira": "bin/jira.js"
56 |   },
57 |   "husky": {
58 |     "hooks": {
59 |       "pre-push": "npm test"
60 |     }
61 |   },
62 |   "devDependencies": {
63 |     "ava": "^3.13.0",
64 |     "eslint": "^6.8.0",
65 |     "husky": "^4.3.0",
66 |     "jest": "^25.3.0",
67 |     "rimraf": "^3.0.2",
68 |     "testr": "0.0.5"
69 |   }
70 | }
71 | 


--------------------------------------------------------------------------------
/test/unit/utils/file-api.spec.js:
--------------------------------------------------------------------------------
 1 | /*globals, jest, describe*/
 2 | const utils = require('../../../lib/utils');
 3 | const fs = require('fs');
 4 | jest.mock('fs');
 5 | 
 6 | describe('utils module', function () {
 7 |   beforeEach(() => {
 8 |     jest.clearAllMocks();
 9 |   });
10 |   describe('createDirectory', function () {
11 |     it('should create directory, when directory not exist', () => {
12 |       //Arrange
13 |       fs.existsSync.mockReturnValue(false);
14 |       //Action
15 |       utils.createDirectory('directoryToCreate');
16 |       //Assert
17 |       expect(fs.mkdir).toHaveBeenCalled();
18 |     });
19 | 
20 |     it('should not create directory, when directory exist', () => {
21 |       //Arrange
22 |       fs.existsSync.mockReturnValue(true);
23 |       //Action
24 |       utils.createDirectory('directoryToCreate');
25 |       //Assert
26 |       expect(fs.mkdir).not.toHaveBeenCalled();
27 |     });
28 |   });
29 | 
30 |   describe('deleteFile', function () {
31 |     it('should delete file, when file exist', () => {
32 |       //Arrange
33 |       fs.existsSync.mockReturnValue(true);
34 | 
35 |       //Action
36 |       utils.deleteFile('aaa/filetodelete');
37 | 
38 |       //Assert
39 |       expect(fs.unlinkSync).toHaveBeenCalled();
40 |       expect(fs.unlinkSync).toHaveBeenCalledWith('aaa/filetodelete');
41 |     });
42 | 
43 |     it('should not try to delete file, when file not exist', () => {
44 |       //Arrange
45 |       fs.existsSync.mockReturnValue(false);
46 | 
47 |       //Action
48 |       utils.deleteFile('aaa/filetodelete');
49 | 
50 |       //Assert
51 |       expect(fs.unlinkSync).not.toHaveBeenCalled();
52 |     });
53 |   });
54 | });
55 | 
56 | 


--------------------------------------------------------------------------------
/test/unit/utils/format-api.spec.js:
--------------------------------------------------------------------------------
 1 | /*globals, jest, describe*/
 2 | const utils = require('../../../lib/utils');
 3 | 
 4 | describe('utils module', function () {
 5 |   let responseWithErrors;
 6 | 
 7 |   beforeEach(() => {
 8 |     responseWithErrors = {
 9 |       'statusCode': 400,
10 |       'body': {
11 |         'errorMessages': [],
12 |         'errors': {
13 |           'issue1': 'Issue1 text',
14 |           'issue2': 'Issue2 text'
15 |         }
16 |       }
17 |     };
18 |   });
19 | 
20 |   describe('extractErrorMessages', function () {
21 |     it('should return array of error messages, when errors exists and object', () => {
22 |       //Arrange
23 |       //Action
24 |       const arrMessages = utils.extractErrorMessages(responseWithErrors);
25 |       //Assert
26 |       expect(arrMessages.length).toBe(Object.keys(responseWithErrors.body.errors).length);
27 |     });
28 | 
29 |     it('should return array of error messages, when errors exists and response string', () => {
30 |       //Arrange
31 |       //Action
32 |       const arrMessages = utils.extractErrorMessages(JSON.stringify(responseWithErrors));
33 |       //Assert
34 |       expect(arrMessages.length).toBe(Object.keys(responseWithErrors.body.errors).length);
35 |     });
36 | 
37 |     it('should return empty array, when errors not exists', () => {
38 |       //Arrange
39 |       responseWithErrors.body.errors = undefined;
40 |       //Action
41 |       const arrMessages = utils.extractErrorMessages(responseWithErrors);
42 |       //Assert
43 |       expect(arrMessages.length).toBe([].length);
44 |     });
45 |   });
46 | });
47 | 
48 | 


--------------------------------------------------------------------------------