tefoji 1.0.7

data/lib/tefoji/jira_api.rb

@@ -0,0 +1,430 @@
+require 'base64'
+require 'io/console'
+require 'json'
+require 'rest-client'
+
+module Tefoji
+  ## An interface to send API request to Jira using the rest-client gem.
+  ## Contained here are the bits of knowledge necessary to form API calls to Jira.
+
+  class JiraApi
+    attr_reader :jira_username, :jira_base_url, :jira_base_rest_url, :log_level
+    attr_accessor :logger
+
+    include Logging
+
+    ## Jira field keys
+    FIELD_ID = 'id'
+    FIELD_KEY = 'key'
+    FIELD_NAME = 'name'
+    FIELD_VALUE = 'value'
+
+    ## Issue type constants
+    ISSUE_EPIC = 'Epic'
+    ISSUE_FEATURE = 'Feature'
+    ISSUE_NEW_FEATURE = 'New Feature'
+    ISSUE_SUB_TASK = 'Sub-task'
+    ISSUE_TASK = 'Task'
+
+    def log_level=(level)
+      @log_level = level
+      # When debugging, turn on the RestClient @logger
+      RestClient.log = @logger if @log_level == Logger::DEBUG
+    end
+
+    # Depending on how user specified their authorization we want to
+    # derive and store the username and the Base64-encoded
+    # 'username:password' string.
+    def authenticate(jira_base_url, requested_user = nil, jira_auth_string = nil)
+      @jira_base_url = jira_base_url
+      @jira_base_rest_url = "#{jira_base_url}/rest/api/2"
+
+      @logger.info "Using Jira instance: \"#{jira_base_url}\""
+
+      # If we found an auth string, try to use it. Allow the requested_user
+      # to override and send us to prompt
+      decoded_auth = nil
+      unless jira_auth_string.nil?
+        auth_string_user, auth_string_password = Base64.decode64(jira_auth_string).split(':')
+        # Only set decoded auth if the user name in the auth string matches the
+        # requested user name
+        unless requested_user && requested_user != auth_string_user
+          decoded_auth = [auth_string_user, auth_string_password]
+        end
+      end
+
+      # If there was no auth string or the requested user didn't match the auth string
+      # prompt for details as needed.
+      if decoded_auth.nil?
+        decoded_auth = []
+        decoded_auth[0] = requested_user
+        if requested_user.nil?
+          print 'Enter jira user name: '
+          decoded_auth[0] = $stdin.gets.chomp
+        end
+        decoded_auth[1] = IO.console.getpass("Enter jira password for #{requested_user}: ")
+      end
+
+      @jira_username = decoded_auth[0]
+
+      # HTTP doesn't like linefeeds in the auth string, hence #strict_encode64
+      @jira_auth_string = Base64.strict_encode64(decoded_auth.join(':'))
+      @authentication_header = { 'Authorization' => "Basic #{@jira_auth_string}" }
+    end
+
+    # Do this so we can inform the user quickly that their credentials didn't work
+    # There may be a better test, but this is the one the original Winston uses
+    def test_authentication
+      get_username
+    rescue RestClient::Forbidden
+      fatal 'Forbidden: either the authentication is incorrect or ' \
+            'Jira might be requiring a CAPTCHA response from the web interface.'
+    end
+
+    def get_username
+      jira_get("user?username=#{@jira_username}")
+    end
+
+    # Save authentication YAML to the a file for reuse.
+    def save_authentication(save_file_name)
+      backup_file_name = "#{save_file_name}.bak"
+
+      if File.readable?(save_file_name)
+        FileUtils.cp(save_file_name, backup_file_name)
+        @logger.info "Saved #{save_file_name} to #{backup_file_name}"
+      end
+
+      File.open(save_file_name, 'w') do |f|
+        f.puts "jira-auth: #{@jira_auth_string}"
+      end
+      File.chmod(0o600, save_file_name)
+
+      @logger.info "Saved Jira authentication to #{save_file_name}"
+    end
+
+    # Create a Jira issue
+    def create_issue(issue_data)
+      request_path = 'issue'
+      jira_fields = issue_data_to_jira_fields(issue_data)
+      jira_post(request_path, jira_fields)
+    rescue RestClient::Forbidden
+      fatal "Forbidden: could not send #{request_path} request to Jira. "\
+            'Jira may not be accepting requests.'
+    rescue RestClient::BadRequest => e
+      error_json = JSON.parse(e.response.body)
+      errors = error_json['errors'].values.join("\n")
+      fatal "Bad Request: something went wrong with this #{request_path} request: "\
+            "#{request_path}, #{jira_fields}\n" \
+            "Errors were: #{errors}"
+    rescue RestClient::Unauthorized
+      fatal "Unauthorized: could not send #{request_path} request to Jira. "\
+            'Did you use the correct credentials?'
+    end
+
+    # Use greehopper to add an issue to an epic. See the comments around the #greenhopper_put
+    # method for more explanation.
+    def add_issue_to_epic(epic_issue, issue_to_add)
+      epic_key = epic_issue[FIELD_KEY]
+      issue_key = issue_to_add[FIELD_KEY]
+      request_path = "epics/#{epic_key}/add"
+      request_data = {
+        'ignoreEpics' => true,
+        'issueKeys' => [issue_key]
+      }
+      greenhopper_put(request_path, request_data)
+    end
+
+    def retrieve_issue(issue_url)
+      jira_get(issue_url)
+    end
+
+    def link_issues(inward_issue, outward_issue, type = 'Blocks')
+      request_path = 'issueLink'
+      request_data = {
+        'type' => { 'name' => type },
+        'inwardIssue' => { 'key'  => inward_issue },
+        'outwardIssue' => { 'key' => outward_issue }
+      }
+      jira_post(request_path, request_data)
+    end
+
+    # Used to set issue items related to transitions.
+    # Right now, only used for 'status' transitions.
+    def transition(issue_key, status)
+      request_path = "issue/#{issue_key}/transitions"
+      request_data = {
+        'transition' => { 'id' => status }
+      }
+      jira_post(request_path, request_data)
+    end
+
+    # https://www.youtube.com/watch?v=JsntlJZ9h1U
+    def add_watcher(issue_key, watcher)
+      request_path = "issue/#{issue_key}/watchers"
+      request_data = watcher
+      jira_post(request_path, request_data)
+    end
+
+    private
+
+    def jira_get(jira_request_path)
+      # Jira likes to send complete URLs for responses. Handle
+      # the case where we've received a 'self' query from Jira with
+      # fully formed url
+      url = jira_request_path
+      unless url.start_with? @jira_base_rest_url
+        url = "#{@jira_base_rest_url}/#{jira_request_path}"
+      end
+      headers = @authentication_header
+
+      begin
+        response = RestClient.get(url, headers)
+      rescue RestClient::MovedPermanently,
+             RestClient::Found,
+             RestClient::TemporaryRedirect => e
+        e.response.follow_redirection
+      rescue RestClient::Unauthorized
+        fatal "'Unauthorized' response from #{@jira_base_rest_url}. " \
+              'Did you use the correct credentials?'
+      rescue RestClient::ServiceUnavailable
+        fatal "Cannot connect to #{@jira_base_rest_url}: Service Unavailable"
+      rescue RestClient::NotFound,
+             SocketError,
+             Errno::ECONNREFUSED => e
+        fatal "Cannot connect to #{@jira_base_rest_url}: #{e.message}"
+      end
+
+      return JSON.parse(response.body)
+    end
+
+    def jira_post(jira_request_path, payload)
+      url = "#{@jira_base_rest_url}/#{jira_request_path}/"
+      json_header = { 'Content-Type' => 'application/json' }
+      headers = @authentication_header.merge(json_header)
+
+      begin
+        response = RestClient.post(url, payload.to_json, headers)
+      rescue RestClient::MovedPermanently,
+             RestClient::Found,
+             RestClient::TemporaryRedirect => e
+        e.response.follow_redirection
+      end
+
+      return JSON.parse(response.body) unless response.body.empty?
+    end
+
+    # Using JIRA's REST API to update the Epic Link field returns "204 No Content",
+    # even if the request is successful. As a workaround, use JIRA's "greenhopper" API.
+    # See the following for reference:
+    # https://jira.atlassian.com/browse/JRA-43437
+    # https://jira.atlassian.com/browse/JSW-7017
+    # https://confluence.atlassian.com/jirakb/set-the-epic-link-via-rest-call-779158620.html
+    #
+    # Special-cased here for hopeful eventual removal
+    def greenhopper_put(request_path, payload)
+      greenhopper_base_rest_url = "#{@jira_base_url}:443/rest/greenhopper/1.0"
+      url = "#{greenhopper_base_rest_url}/#{request_path}/"
+      json_header = { 'Content-Type' => 'application/json' }
+      headers = @authentication_header.merge(json_header)
+
+      begin
+        response = RestClient.put(url, payload.to_json, headers)
+      rescue RestClient::MovedPermanently,
+             RestClient::Found,
+             RestClient::TemporaryRedirect => e
+        e.response.follow_redirection
+      end
+
+      return JSON.parse(response.body) unless response.body.empty?
+    end
+
+    # Provide the needed translation of user-created data to required format
+    # of Jira requests. This is mostly a list of fussing with the Jira field
+    # names.
+    def issue_data_to_jira_fields(issue_data)
+      # Check to ensure we have what we need to create a issue
+
+      unless issue_data['summary']
+        @logger.error "this issue is missing a required summary:\n\n#{issue_data}\n"
+        exit 1
+      end
+      unless issue_data['project']
+        @logger.error "this issue is missing a required project:\n\n#{issue_data}\n"
+        exit 1
+      end
+
+      # build the jira_fields hash describing the issue
+
+      # These are required for all issues
+      jira_fields = {
+        'summary' => issue_data['summary'],
+        'project' => { 'key' => issue_data['project'] }
+      }
+
+      # The following are optional
+      if issue_data['description']
+        jira_fields['description'] = issue_data['description']
+      end
+      if issue_data['assignee']
+        jira_fields['assignee'] = { FIELD_NAME => issue_data['assignee'] }
+      end
+      if issue_data['story_points']
+        jira_fields['customfield_10002'] = issue_data['story_points'].to_i
+      end
+      if issue_data['team']
+        jira_fields['customfield_14200'] = { FIELD_VALUE => issue_data['team'] }
+      end
+      if issue_data['teams']
+        teams = issue_data['teams'].to_a.flatten.reject { |t| t =~ /^\s*$/ }
+        unless teams.empty?
+          jira_fields['customfield_14201'] = teams.map { |team| { FIELD_VALUE => team } }
+        end
+      end
+      if issue_data['subteam']
+        jira_fields['customfield_11700'] = [issue_data['subteam']]
+      end
+      if issue_data['sprint']
+        jira_fields['customfield_10005'] = issue_data['sprint'].to_i
+      end
+      if issue_data['acceptance']
+        jira_fields['customfield_11501'] = issue_data['acceptance']
+      end
+      if issue_data['labels']
+        labels = issue_data['labels'].to_a.flatten.reject { |t| t =~ /^\s*$/ }
+        jira_fields['labels'] = labels unless labels.empty?
+      end
+      if issue_data['duedate']
+        jira_fields['duedate'] = issue_data['duedate']
+      end
+      if issue_data['fix_version']
+        jira_fields['fixVersions'] = [issue_data['fix_version']]
+      end
+      if issue_data['release_notes']
+        jira_fields['customfield_11100'] = { FIELD_VALUE => issue_data['release_notes'] }
+      end
+
+      if issue_data['components']
+        components = issue_data[:components].to_a.flatten.reject { |t| t =~ /^\s*$/ }
+        unless components.empty?
+          jira_fields['components'] = components.map { |component| { FIELD_NAME => component } }
+        end
+      end
+
+      # Default issue type to ISSUE_TASK if it isn't already set
+      jira_fields['issuetype'] = { FIELD_NAME => ISSUE_TASK }
+
+      if issue_data['type']
+        jira_fields['issuetype'] = { FIELD_NAME => issue_data['type'] }
+        # If this is an epic, we need to add an epic name
+        if issue_data['type'].casecmp?(ISSUE_EPIC)
+          jira_fields['customfield_10007'] = issue_data['epic_name'] || issue_data['summary']
+        end
+      end
+
+      # If a issue has a specified parent issue, prefer that. The parent issue *should* already
+      # be linked to the main epic. Otherwise, we need to set it to have an epic_parent. This can
+      # either be an epic linked to the main epic or the main epic itself.
+
+      if issue_data['parent']
+        unless issue_data['type'].casecmp?(ISSUE_SUB_TASK) || !issue_data['type']
+          @logger.fatal "A issue with a parent must be classified as a Sub-issue\n\n#{issue_data}"
+          exit 1
+        end
+        jira_fields['issuetype'] = { FIELD_NAME => ISSUE_SUB_TASK }
+        jira_fields['parent'] = { FIELD_KEY => issue_data['parent'] }
+      elsif issue_data['epic_parent']
+        if issue_data['type'].casecmp?(ISSUE_SUB_TASK)
+          @logger.fatal "This issue cannot be a subtask of an epic\n\n#{issue_data}"
+          exit 1
+        end
+        jira_fields['customfield_10006'] = issue_data['epic_parent']
+      end
+
+      security = ENV['SECURITY'] || issue_data['security']
+      if security
+        case security.downcase
+        when 'confidential'
+          jira_fields['security'] = { FIELD_ID => '10002' }
+        when 'internal'
+          jira_fields['security'] = { FIELD_ID => '10001' }
+        when 'public'
+          # Nothing to do here - public is default
+        else
+          @logger.fatal "Unknown security type: #{security}"
+          exit 1
+        end
+      end
+
+      return { 'fields' => jira_fields }
+    end
+  end
+
+  class JiraMockApi < JiraApi
+    def initialize(log_level = Logger::ERROR)
+      super
+      @key_count = 0
+      @summary_count = 0
+    end
+
+    def authenticate(jira_base_url, username = nil, jira_auth_string = nil)
+      @jira_base_url = jira_base_url
+      @jira_base_rest_url = "#{jira_base_url}/rest/api/2"
+
+      @logger.info "Using mock of Jira instance: \"#{jira_base_url}\""
+
+      if jira_auth_string.nil?
+        if username.nil?
+          print 'Enter jira user name: '
+          username = $stdin.gets.chomp
+        end
+      else
+        plain_auth_string = Base64.decode64(jira_auth_string)
+        username = plain_auth_string.split(':')[0]
+      end
+
+      @jira_username = username
+    end
+
+    def jira_get(jira_request_path)
+      url = "#{@jira_base_rest_url}/#{jira_request_path}"
+      header = { 'Authorization' => 'Basic mocked-auth-header' }
+      puts "\n  RestClient.get #{url} #{header}\n"
+      mocked_response
+    end
+
+    def jira_post(jira_request_path, payload)
+      url = "#{@jira_base_rest_url}/#{jira_request_path}/"
+      # json_header = { 'Content-Type' => 'application/json' }
+      # headers = { 'Authorization' => 'Basic mocked-auth-header' }.merge(json_header)
+
+      puts "\n  RestClient.post #{url}\n  #{pretty(payload)}\n\n"
+      mocked_response
+    end
+
+    def greenhopper_put(request_path, payload)
+      greenhopper_base_rest_url = "#{@jira_base_url}:443/rest/greenhopper/1.0"
+      url = "#{greenhopper_base_rest_url}/#{request_path}/"
+      # json_header = { 'Content-Type' => 'application/json' }
+      # headers = { 'Authorization' => 'Basic mocked-auth-header' }.merge(json_header)
+
+      puts "\n  RestClient.put #{url}\n  #{pretty(payload)}\n\n"
+      mocked_response
+    end
+
+    def pretty(issue_data)
+      JSON.pretty_generate(issue_data)
+    end
+
+    def mocked_response
+      @key_count += 1
+      @summary_count += 1
+
+      return {
+        'key' => "MOCKED-#{@key_count}",
+        'fields' => {
+          'summary' => "Mocked issue summary #{@summary_count}"
+        }
+      }
+    end
+  end
+end