jira-cli/lib/jira/edit.js

A JIRA Command Line Interface

/*global requirejs,console,define,fs*/
module.exports = function () {
  const promptly = require('promptly');

  var sslRequest = require('../../lib/ssl_request');

  var config = require('../../lib/config');

  var common = require('../../lib/common');

  var async = require('async');

  var editMeta = {
    ask: function (question, callback, yesno, values, answer) {
      var that = this,
        issueTypes = [],
        i = 0;

      if (answer || answer === false) {
        return callback(answer);
      }

      if (values && values.length > 0) {
        for (i; i < values.length; i++) {
          if (that.isSubTask) {
            if (values[i].subtask !== undefined) {
              if (values[i].subtask) {
                issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
              }
            } else {
              issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
            }
          } else {
            if (!values[i].subtask) {
              issueTypes.push('(' + values[i].id + ') ' + (values[i].name ? values[i].name : values[i].value));
            }
          }
        }

        console.log(issueTypes.join('\n'));
      }

      var match;
      promptly
        .prompt(question)
        .then(answer => {
          debugger;
  
          if (answer.length > 0) {
            values && values.forEach(function (eachValue) {
              if (eachValue.id == answer || eachValue.value == answer || eachValue.name == answer) {
                answer = eachValue.value;
                match = true;
              }
            });
  
            if (values) {
              if (match) {
                return callback(answer);
              } else {
                editMeta.ask(question, callback, yesno, values);
              }
            } else {
              return callback(answer);
            }
          } else {
            if (yesno) {
              callback(false);
            } else {
              editMeta.ask(question, callback);
            }
          }
        })
        .catch(e => {
          if(e && e.message === 'canceled') {
            console.log('\nInput cancelled');
          } else {
            console.log('\nError: ' + e.toString());
          }
        });
    },
    getMeta: function (issue, callback) {
      this.query = 'rest/api/2/issue/' + issue + '/editmeta';
      sslRequest.get(config.auth.url + this.query).end((err, res) => {
        try {
          if (!res.ok) {
            console.log((res.body.errorMessages || [res.error]).join('\n'));
            return callback((res.body.errorMessages || [res.error]).join('\n'));
          }
        } catch(e) {
          if (err && err.message) {
            return callback(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
          }
          return callback(e);
        }

        callback(null, res.body.fields);
      });
    },
    getOutputFormat: function (meta, issue, field, value, putBody, cb) {
      //handling without callback scenarios
      if (!cb) {
        cb = function (err, result) {
          if (err) {
            throw err;
          } else {
            return result;
          }
        };
      }

      var editing = meta[field];

      if (!editing || !editing.schema) {
        return cb(new Error('wrong meta'));
      }

      if (!putBody.fields) {
        putBody.fields = {};
      }

      var formattedValue;

      if (editing.schema.type == 'string') {
        formattedValue = value.toString();
      } else if (editing.schema.type == 'array') {
        //how to give multiple inputs
        if (editing.schema.items == 'string') {
          formattedValue = value.toString().split(',');
        }
      } else if (editing.schema.type == 'any') {
        console.log('not yet supported');
      } else if (editing.schema.type == 'priority') {
        formattedValue = {
          id: value
        };
      }

      if (!formattedValue) {
        return cb(new Error('this type of field is not supported yet'));
      }

      putBody.fields[field] = formattedValue;
      return cb(null, putBody);
    },
    makeEditCall: function (issue, putbody, cb) {
      this.query = 'rest/api/2/issue/' + issue;
      sslRequest.put(config.auth.url + this.query).send(putbody).end((err, res) => {
        try {
          if (!res.ok) {
            console.log(res);

            if (res.body && res.body.errorMessages) {
              console.log(res.body && res.body.errorMessages && res.body.errorMessages.join('\n'));
              return cb(res.body.errorMessages.join('\n'));
            }

            return cb(new Error('some error'));
          }
        } catch(e) {
          if (err && err.message) {
            return cb(`A connection error occurred: Error Number: ${err.errno} | Message: ${err.message}`)
          }
          return cb(e);
        }

        console.log('Issue edited successfully!');
        return cb();
      });
    },
    editWithInputPutBody: function (issue, input, cb) {
      editMeta.getMeta(issue, function (err, meta) {
        if (err) {
          return cb(err);
        }

        var putBody = {};

        if (config && config.edit_meta && config.edit_meta['__default'] && config.edit_meta['__default'][input]) {
          putBody = config.edit_meta['__default'][input];
        } else {
          var parsedInputMap = editMeta.parseEditInput(input);
          Object.keys(parsedInputMap).forEach(function (eachField) {
            putBody = editMeta.getOutputFormat(meta, issue, eachField, parsedInputMap[eachField], putBody);
          });
        }

        editMeta.makeEditCall(issue, putBody, cb);
      });
    },
    parseEditInput: function (input) {
      var inputArr = input.toString().split(';;');
      var singleInput, inputKey, inputValue, finalKey, finalValue;
      var inputObj = {};
      inputArr.forEach(function (eachInput) {
        singleInput = eachInput.split('::');
        inputKey = singleInput[0];
        inputValue = singleInput[1];

        if (config && config.edit_meta && config.edit_meta[inputKey]) {
          if (config.edit_meta[inputKey].key) {
            finalKey = config.edit_meta[inputKey].key;
          }

          if (config.edit_meta[inputKey].default && config.edit_meta[inputKey].default[inputValue]) {
            finalValue = config.edit_meta[inputKey].default[inputValue];
          }
        } else {
          finalKey = inputKey;
          finalValue = inputValue;
        }

        inputObj[finalKey] = finalValue;
      });
      return inputObj;
    },
    edit: function (issue, cb) {
      editMeta.getMeta(issue, function (err, meta) {
        if (err) {
          return cb(err);
        }

        var metaInput = [];
        Object.keys(meta).forEach(function (eachMeta, index) {
          metaInput.push({
            id: index,
            value: eachMeta,
            name: meta[eachMeta].name
          });
        });
        editMeta.ask('enter Input ', function (answer) {
          console.log(answer);
          var inputOptions;

          if (meta[answer] && meta[answer].allowedValues && meta[answer].allowedValues.length) {
            inputOptions = meta[answer].allowedValues;
          }

          common.ask('Enter value ', function (answerValue) {
            var putBody = {};
            editMeta.getOutputFormat(meta, issue, answer, answerValue, putBody, function (err, putBody) {
              if (err) {
                return cb(err);
              }

              editMeta.makeEditCall(issue, putBody, cb);
            });
          }, null, inputOptions);
        }, null, metaInput);
      });
    }
  };
  return editMeta;
}();