class Jira::Request

Generic Jira request

Attributes

children[RW]

request children

config[RW]

request config - host, api resource, etc

data_map[RW]

mapping between our dsl keywords and Jira's json fields

fields[RW]

request fields that were set

json_data[RW]

request data to send to server

key[RW]

issue key

request_parent[RW]

request parent - used when creating subtasks

request_type[RW]

request type (create, update)

response[RW]

request response

Public Class Methods

new(type, config = {}) click to toggle source
# File lib/jira-script/request.rb, line 37
def initialize(type, config = {})
  self.request_type = type
  self.config = config
  self.fields = {}
  self.request_parent = nil
  self.json_data = {}
  self.children = []
  self.key = nil
  init_data_map
end

Public Instance Methods

_error(msg) click to toggle source
# File lib/jira-script/request.rb, line 101
def _error(msg)
  if request_type == :create
    raise RequestException, "Error trying to create ticket #{fields[:summary]}: #{msg}"
  elsif request_type == :update
    raise RequestException, "Error trying to update ticket #{key}: #{msg}"
              elsif request_type == :search
                      raise RequestException, "Error searching for issues: #{msg}"
  end
end
_set_default_type() click to toggle source
# File lib/jira-script/request.rb, line 72
def _set_default_type
  # set default type if empty
  return if fields.key?(:type)
  if fields.key?(:parent)
    type config[:default_subtask_type]
  else
    type config[:default_issue_type]
  end
end
_set_field(name, val) click to toggle source
# File lib/jira-script/request.rb, line 95
def _set_field(name, val)
  raise RequestException, "Invalid request parameter #{name}" unless data_map.key?(name)
  fields[name] = val
  _set_xpath(json_data, data_map[name], val)
end
_set_xpath(h, xpath, value) click to toggle source
# File lib/jira-script/request.rb, line 82
def _set_xpath(h, xpath, value)
  len = xpath.length
  pos = xpath.index('/')
  if pos.nil?
    h[xpath.to_sym] = value
  else
    key = xpath[0..pos - 1].to_sym
    h[key] = h[key] || {}
    _set_xpath(h[key], xpath[pos + 1..len], value)
  end
  h
end
components(*args) click to toggle source
# File lib/jira-script/request.rb, line 220
def components(*args)
  vals = []
  args.each do |arg|
    vals.push name: arg
  end

  _set_field(:components, vals)
end
create(summary, &block) click to toggle source
# File lib/jira-script/request.rb, line 205
def create(summary, &block)
  subtask(summary, &block)
end
init_data_map() click to toggle source
# File lib/jira-script/request.rb, line 48
def init_data_map
  self.data_map = {
      project: 'fields/project/key',
      parent: 'fields/parent/key',
      summary: 'fields/summary',
      description: 'fields/description',
      type: 'fields/issuetype/name',
      assignee: 'fields/assignee/name',
      reporter: 'fields/reporter/name',
      estimate: 'fields/timetracking/originalEstimate',
      remaining: 'fields/timetracking/remainingEstimate',
      components: 'fields/components',
      labels: 'fields/labels'
  }
end
labels(*args) click to toggle source
# File lib/jira-script/request.rb, line 229
def labels(*args)
  _set_field(:labels, [*args])
end
method_missing(name, *args, &block) click to toggle source
Calls superclass method
# File lib/jira-script/request.rb, line 115
def method_missing(name, *args, &block)
  if data_map.key?(name)
    _set_field(name, args[0])
  else
    super
  end
end
respond_to_missing?(method_name, include_private = false) click to toggle source
Calls superclass method
# File lib/jira-script/request.rb, line 111
def respond_to_missing?(method_name, include_private = false)
  data_map.key?(method_name) || super
end
run() click to toggle source
# File lib/jira-script/request.rb, line 140
def run
  ret = nil
              _set_default_type if [:create, :update].include?(request_type)
  url = [config[:host], config[:api_path], config[:resource]].join('/')
              json_str = to_json 
              puts "url: #{url}" if config[:verbosity] >= 2 
  puts "json: #{json_str}" if config[:verbosity] >= 2

  req = Typhoeus::Request.new(
      url,
      ssl_verifypeer: false,
      method: config[:http_request_type],
      userpwd: "#{config[:user]}:#{config[:password]}",
                              body: json_str,
                              headers: { 'Content-Type' => 'application/json' }.merge(config[:headers])
  )
  req.on_complete do |response|
    if response.success?
                              if !response.body.empty?
              self.response = JSON.parse(response.body, symbolize_names: true)
                              else
                                      self.response = response
                              end
   
                           if config[:response_node] == nil
                                      ret = self.response
                              else        
                                      ret = self.response[config[:response_node]]
                              end
      self.key = ret if request_type == :create

                              if [:create, :update].include?(request_type)
                                      if config[:verbosity] >= 1
                                              if fields[:parent].nil?
                                                      prefix = 'Issue'
                                              else
                                                      prefix = '  - sub-task'
                                              end
                                              puts "#{prefix} #{key} updated successfully" if request_type == :update
                                              puts "#{prefix} #{key}: '#{fields[:summary]}' created successfully" if request_type == :create
                                      end
                              end

      unless children.empty?
        children.each do |child|
          child.parent key
          child.run
        end
      end
    elsif response.timed_out?
      _error('timeout')
    elsif response.code.zero?
      # Could not get an http response, something's wrong.
      _error(response.return_message)
    else
      # Received a non-successful http response.
      _error('HTTP request failed: ' + response.code.to_s + ' / message: ' + response.body)
    end
  end

  req.run

  ret
end
subtask(summary, &block) click to toggle source
# File lib/jira-script/request.rb, line 209
def subtask(summary, &block)
  raise RequestException, "Sub-task '#{fields[:summary]}' cannot have other sub-tasks" unless request_parent.nil?
  request = Request.new(:create, config)
  request.config[:http_request_type] = :post
  request.request_parent = self
  children.push request
  request.summary summary
  request.project fields[:project]
  request.instance_eval(&block) if block_given?
end
to_json() click to toggle source
# File lib/jira-script/request.rb, line 64
def to_json
              JSON.generate(json_data.merge(config[:body]))
end
to_s() click to toggle source
# File lib/jira-script/request.rb, line 68
def to_s
              json_data.merge(config[:body])
end
upload() click to toggle source
# File lib/jira-script/request.rb, line 123
    def upload
ret = nil
url = [config[:host], config[:api_path], config[:resource]].join('/')
            _body = self.json_data.merge(config[:body])
            puts "url: #{url}" if config[:verbosity] >= 2
puts "body: #{_body}" if config[:verbosity] >= 2

Typhoeus::Request.post(
    url,
    ssl_verifypeer: false,
    userpwd: "#{config[:user]}:#{config[:password]}",
                            body: _body,
                            headers: {'Content-Type' => 'application/x-www-form-urlencoded' }.merge(config[:headers])
)

    end