jira-ruby 2.1.3

data/lib/jira/http_error.rb

@@ -0,0 +1,14 @@
+require 'forwardable'
+module JIRA
+  class HTTPError < StandardError
+    extend Forwardable
+
+    def_instance_delegators :@response, :code
+    attr_reader :response, :message
+
+    def initialize(response)
+      @response = response
+      @message = response.try(:message).presence || response.try(:body)
+    end
+  end
+end

data/lib/jira/jwt_client.rb

@@ -0,0 +1,67 @@
+require 'atlassian/jwt'
+
+module JIRA
+  class JwtClient < HttpClient
+    def make_request(http_method, url, body = '', headers = {})
+      @http_method = http_method
+
+      super(http_method, url, body, headers)
+    end
+
+    def make_multipart_request(url, data, headers = {})
+      @http_method = :post
+
+      super(url, data, headers)
+    end
+
+    class JwtUriBuilder
+      attr_reader :request_url, :http_method, :shared_secret, :site, :issuer
+
+      def initialize(request_url, http_method, shared_secret, site, issuer)
+        @request_url = request_url
+        @http_method = http_method
+        @shared_secret = shared_secret
+        @site = site
+        @issuer = issuer
+      end
+
+      def build
+        uri = URI.parse(request_url)
+        new_query = URI.decode_www_form(String(uri.query)) << ['jwt', jwt_header]
+        uri.query = URI.encode_www_form(new_query)
+
+        return uri.to_s unless uri.is_a?(URI::HTTP)
+
+        uri.request_uri
+      end
+
+      private
+
+      def jwt_header
+        claim = Atlassian::Jwt.build_claims \
+          issuer,
+          request_url,
+          http_method.to_s,
+          site,
+          (Time.now - 60).to_i,
+          (Time.now + 86_400).to_i
+
+        JWT.encode claim, shared_secret
+      end
+    end
+
+    private
+
+    attr_reader :http_method
+
+    def request_path(url)
+      JwtUriBuilder.new(
+        url,
+        http_method.to_s,
+        @options[:shared_secret],
+        @options[:site],
+        @options[:issuer]
+      ).build
+    end
+  end
+end

data/lib/jira/oauth_client.rb

@@ -0,0 +1,114 @@
+require 'oauth'
+require 'json'
+require 'forwardable'
+
+module JIRA
+  class OauthClient < RequestClient
+    DEFAULT_OPTIONS = {
+      signature_method: 'RSA-SHA1',
+      request_token_path: '/plugins/servlet/oauth/request-token',
+      authorize_path: '/plugins/servlet/oauth/authorize',
+      access_token_path: '/plugins/servlet/oauth/access-token',
+      private_key_file: 'rsakey.pem',
+      consumer_key: nil,
+      consumer_secret: nil
+    }.freeze
+
+    # This exception is thrown when the client is used before the OAuth access token
+    # has been initialized.
+    class UninitializedAccessTokenError < StandardError
+      def message
+        'init_access_token must be called before using the client'
+      end
+    end
+
+    extend Forwardable
+
+    attr_accessor :consumer
+    attr_reader :options
+
+    def_instance_delegators :@consumer, :key, :secret, :get_request_token
+
+    def initialize(options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @consumer = init_oauth_consumer(@options)
+    end
+
+    def init_oauth_consumer(_options)
+      @options[:request_token_path] = @options[:context_path] + @options[:request_token_path]
+      @options[:authorize_path] = @options[:context_path] + @options[:authorize_path]
+      @options[:access_token_path] = @options[:context_path] + @options[:access_token_path]
+      # proxy_address does not exist in oauth's gem context but proxy does
+      @options[:proxy] = @options[:proxy_address] if @options[:proxy_address]
+      OAuth::Consumer.new(@options[:consumer_key], @options[:consumer_secret], @options)
+    end
+
+    # Returns the current request token if it is set, else it creates
+    # and sets a new token.
+    def request_token(options = {}, *arguments, &block)
+      @request_token ||= get_request_token(options, *arguments, block)
+    end
+
+    # Sets the request token from a given token and secret.
+    def set_request_token(token, secret)
+      @request_token = OAuth::RequestToken.new(@consumer, token, secret)
+    end
+
+    # Initialises and returns a new access token from the params hash
+    # returned by the OAuth transaction.
+    def init_access_token(params)
+      @access_token = request_token.get_access_token(params)
+    end
+
+    # Sets the access token from a preexisting token and secret.
+    def set_access_token(token, secret)
+      @access_token = OAuth::AccessToken.new(@consumer, token, secret)
+      @authenticated = true
+      @access_token
+    end
+
+    # Returns the current access token. Raises an
+    # JIRA::Client::UninitializedAccessTokenError exception if it is not set.
+    def access_token
+      raise UninitializedAccessTokenError unless @access_token
+      @access_token
+    end
+
+    def make_request(http_method, url, body = '', headers = {})
+      # When using oauth_2legged we need to add an empty oauth_token parameter to every request.
+      if @options[:auth_type] == :oauth_2legged
+        oauth_params_str = 'oauth_token='
+        uri = URI.parse(url)
+        uri.query = if uri.query.to_s == ''
+                      oauth_params_str
+                    else
+                      uri.query + '&' + oauth_params_str
+                    end
+        url = uri.to_s
+      end
+
+      case http_method
+      when :delete, :get, :head
+        response = access_token.send http_method, url, headers
+      when :post, :put
+        response = access_token.send http_method, url, body, headers
+      end
+      @authenticated = true
+      response
+    end
+
+    def make_multipart_request(url, data, headers = {})
+      request = Net::HTTP::Post::Multipart.new url, data, headers
+
+      access_token.sign! request
+
+      response = consumer.http.request(request)
+      @authenticated = true
+      response
+    end
+
+    def authenticated?
+      @authenticated
+    end
+  end
+end

data/lib/jira/railtie.rb

@@ -0,0 +1,10 @@
+require 'jira-ruby'
+require 'rails'
+
+module JIRA
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'tasks/generate.rake'
+    end
+  end
+end

data/lib/jira/request_client.rb

@@ -0,0 +1,31 @@
+require 'oauth'
+require 'json'
+require 'net/https'
+
+module JIRA
+  class RequestClient
+    # Returns the response if the request was successful (HTTP::2xx) and
+    # raises a JIRA::HTTPError if it was not successful, with the response
+    # attached.
+
+    def request(*args)
+      response = make_request(*args)
+      raise HTTPError, response unless response.is_a?(Net::HTTPSuccess)
+      response
+    end
+
+    def request_multipart(*args)
+      response = make_multipart_request(*args)
+      raise HTTPError, response unless response.is_a?(Net::HTTPSuccess)
+      response
+    end
+
+    def make_request(*args)
+      raise NotImplementedError
+    end
+
+    def make_multipart_request(*args)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/jira/resource/agile.rb

@@ -0,0 +1,79 @@
+require 'cgi'
+
+module JIRA
+  module Resource
+    class AgileFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Agile < JIRA::Base
+      # @param client [JIRA::Client]
+      # @param options [Hash<Symbol, Object>]
+      # @return [Hash]
+      def self.all(client, options = {})
+        opts = options.empty? ? '' : "?#{hash_to_query_string(options)}"
+        response = client.get(path_base(client) + "/board#{opts}")
+        parse_json(response.body)
+      end
+
+      def self.get_backlog_issues(client, board_id, options = {})
+        options[:maxResults] ||= 100
+        response = client.get(path_base(client) + "/board/#{board_id}/backlog?#{hash_to_query_string(options)}")
+        parse_json(response.body)
+      end
+
+      def self.get_board_issues(client, board_id, options = {})
+        response = client.get(path_base(client) + "/board/#{board_id}/issue?#{hash_to_query_string(options)}")
+        json = parse_json(response.body)
+        # To get Issue objects with the same structure as for Issue.all
+        return {} if json['issues'].size.zero?
+        issue_ids = json['issues'].map do |issue|
+          issue['id']
+        end
+        client.Issue.jql("id IN(#{issue_ids.join(', ')})")
+      end
+
+      def self.get_sprints(client, board_id, options = {})
+        options[:maxResults] ||= 100
+        response = client.get(path_base(client) + "/board/#{board_id}/sprint?#{hash_to_query_string(options)}")
+        parse_json(response.body)
+      end
+
+      def self.get_sprint_issues(client, sprint_id, options = {})
+        options[:maxResults] ||= 100
+        response = client.get(path_base(client) + "/sprint/#{sprint_id}/issue?#{hash_to_query_string(options)}")
+        parse_json(response.body)
+      end
+
+      def self.get_projects_full(client, board_id, _options = {})
+        response = client.get(path_base(client) + "/board/#{board_id}/project/full")
+        parse_json(response.body)
+      end
+
+      def self.get_projects(client, board_id, options = {})
+        options[:maxResults] ||= 100
+        create_meta_url = path_base(client) + "/board/#{board_id}/project"
+        params = hash_to_query_string(options)
+
+        response = client.get("#{create_meta_url}?#{params}")
+        parse_json(response.body)
+      end
+
+      # def self.find(client, key, options = {})
+      #   options[:maxResults] ||= 100
+      #   fields = options[:fields].join(',') unless options[:fields].nil?
+      #   response = client.get("/rest/api/latest/search?jql=sprint=#{key}&fields=#{fields}&maxResults=#{options[:maxResults]}")
+      #   parse_json(response.body)
+      # end
+
+      private
+
+      def self.path_base(client)
+        client.options[:context_path] + '/rest/agile/1.0'
+      end
+
+      def path_base(client)
+        self.class.path_base(client)
+      end
+    end
+  end
+end

data/lib/jira/resource/applinks.rb

@@ -0,0 +1,39 @@
+module JIRA
+  module Resource
+    class ApplicationLinkFactory < JIRA::BaseFactory # :nodoc:
+      delegate_to_target_class :manifest
+    end
+
+    class ApplicationLink < JIRA::Base
+      REST_BASE_PATH = '/rest/applinks/1.0'.freeze
+
+      def self.endpoint_name
+        'listApplicationlinks'
+      end
+
+      def self.full_url(client)
+        client.options[:context_path] + REST_BASE_PATH
+      end
+
+      def self.collection_path(client, prefix = '/')
+        full_url(client) + prefix + endpoint_name
+      end
+
+      def self.all(client, options = {})
+        response = client.get(collection_path(client))
+        json = parse_json(response.body)
+        json = json['list']
+        json.map do |attrs|
+          new(client, { attrs: attrs }.merge(options))
+        end
+      end
+
+      def self.manifest(client)
+        url = full_url(client) + '/manifest'
+        response = client.get(url)
+        json = parse_json(response.body)
+        JIRA::Base.new(client, attrs: json)
+      end
+    end
+  end
+end

data/lib/jira/resource/attachment.rb

@@ -0,0 +1,50 @@
+require 'net/http/post/multipart'
+
+module JIRA
+  module Resource
+    class AttachmentFactory < JIRA::BaseFactory # :nodoc:
+      delegate_to_target_class :meta
+    end
+
+    class Attachment < JIRA::Base
+      belongs_to :issue
+      has_one :author, class: JIRA::Resource::User
+
+      def self.endpoint_name
+        'attachments'
+      end
+
+      def self.meta(client)
+        response = client.get(client.options[:rest_base_path] + '/attachment/meta')
+        parse_json(response.body)
+      end
+
+      def save!(attrs, path = url)
+        file = attrs['file'] || attrs[:file] # Keep supporting 'file' parameter as a string for backward compatibility
+        mime_type = attrs[:mimeType] || 'application/binary'
+
+        headers = { 'X-Atlassian-Token' => 'nocheck' }
+        data = { 'file' => UploadIO.new(file, mime_type, file) }
+
+        response = client.post_multipart(path, data , headers)
+
+        set_attributes(attrs, response)
+
+        @expanded = false
+        true
+      end
+
+      private
+
+      def set_attributes(attributes, response)
+        set_attrs(attributes, false)
+        return if response.body.nil? || response.body.length < 2
+
+        json = self.class.parse_json(response.body)
+        attachment = json[0]
+
+        set_attrs(attachment)
+      end
+    end
+  end
+end

data/lib/jira/resource/board.rb

@@ -0,0 +1,91 @@
+require 'cgi'
+
+module JIRA
+  module Resource
+    class BoardFactory < JIRA::BaseFactory # :nodoc:
+    end
+
+    class Board < JIRA::Base
+      def self.all(client)
+        path = path_base(client) + '/board'
+        response = client.get(path)
+        json = parse_json(response.body)
+        results = json['values']
+
+        until json['isLast']
+          params = { 'startAt' => (json['startAt'] + json['maxResults']).to_s }
+          response = client.get(url_with_query_params(path, params))
+          json = parse_json(response.body)
+          results += json['values']
+        end
+
+        results.map do |board|
+          client.Board.build(board)
+        end
+      end
+
+      def self.find(client, key, _options = {})
+        response = client.get(path_base(client) + "/board/#{key}")
+        json = parse_json(response.body)
+        client.Board.build(json)
+      end
+
+      def issues(params = {})
+        path = path_base(client) + "/board/#{id}/issue"
+        response = client.get(url_with_query_params(path, params))
+        json = self.class.parse_json(response.body)
+        results = json['issues']
+
+        while (json['startAt'] + json['maxResults']) < json['total']
+          params['startAt'] = (json['startAt'] + json['maxResults'])
+          response = client.get(url_with_query_params(path, params))
+          json = self.class.parse_json(response.body)
+          results += json['issues']
+        end
+
+        results.map { |issue| client.Issue.build(issue) }
+      end
+
+      def configuration(params = {})
+        path = path_base(client) + "/board/#{id}/configuration"
+        response = client.get(url_with_query_params(path, params))
+        json = self.class.parse_json(response.body)
+        client.BoardConfiguration.build(json)
+      end
+
+      # options
+      #   - state ~ future, active, closed, you can define multiple states separated by commas, e.g. state=active,closed
+      #   - maxResults ~ default: 50 (JIRA API), 1000 (this library)
+      #   - startAt ~ base index, starts at 0
+      def sprints(options = {})
+        # options.reverse_merge!(DEFAULT_OPTIONS)
+        response = client.get(path_base(client) + "/board/#{id}/sprint?#{options.to_query}")
+        json = self.class.parse_json(response.body)
+        json['values'].map do |sprint|
+          sprint['rapidview_id'] = id
+          client.Sprint.build(sprint)
+        end
+      end
+
+      def project
+        response = client.get(path_base(client) + "/board/#{id}/project")
+        json = self.class.parse_json(response.body)
+        json['values'][0]
+      end
+
+      def add_issue_to_backlog(issue)
+        client.post(path_base(client) + '/backlog/issue', { issues: [issue.id] }.to_json)
+      end
+
+      private
+
+      def self.path_base(client)
+        client.options[:context_path] + '/rest/agile/1.0'
+      end
+
+      def path_base(client)
+        self.class.path_base(client)
+      end
+    end
+  end
+end