yandex_tracker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4eb7de823552b7b73610f844930961a8acffc1fc96fca5a06d9474f0e1f61b86
+  data.tar.gz: cd15a1d640e61c9d85b8bfb9409f9147d1cfbea17a9dfdc3501dbd7e273b96bd
+SHA512:
+  metadata.gz: 8d2df010caa85f960c4f7693aece42a44a28204ef245f9cdbbebd4a7a34fcc95f14237c166a24e669f71c61229f0f02e61c03310741feb224481bd77ac391bc1
+  data.tar.gz: de1e4b108220cc4a37fb40bf45b877881e60995cea0ef3336af2d45ad79b9cc8adc0e7b19ab2e75599b2055efee180a32baa3a815412c2b4b3efccf706de8350

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,22 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Layout/MethodLength:
+  Max: 30
+
+Metrics/BlockLength:
+  AllowedMethods: ['describe', 'context', 'it']
+
+Metrics/AbcSize:
+  Max: 30

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 - 2024-12-12
+
+* Initial release

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in yandex_tracker.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"
+
+group :test do
+  gem "pry"
+  gem "webmock"
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 kirqe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,122 @@
+# YandexTracker
+
+Ruby API client for [YandexTracker](https://yandex.cloud/en-ru/docs/tracker/about-api) with partially implemented resources for essential needs
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add yandex_tracker
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install yandex_tracker
+
+## Configure
+
+```ruby
+  YandexTracker.configure do |config|
+    config.client_id = "abc"
+    config.client_secret = "def"
+    config.org_id = "123" # or cloud_org_id
+  end
+
+  YandexTracker::Auth.exchange_code(code)
+
+  # or
+
+  YandexTracker.configure do |config|
+    config.access_token = "xyz"
+    config.org_id = "123" # or cloud_org_id
+  end
+```
+
+## Usage
+
+```ruby
+  client = YandexTracker::Client.new
+
+  client.users.myself
+
+  client.workflows.list
+  client.resolutions.list
+
+  myqueue = client.queues.create(
+    key: "MYQUEUE",
+    name: "MYQUEUE",
+    lead: "me", # should have correct name
+    defaultType: "task",
+    defaultPriority: "normal",
+    issueTypesConfig: {
+      issueType: "task",
+      workflow: "developmentPresetWorkflow",
+      resolutions: ["wontFix"]
+    }
+  ) #<YandexTracker::Objects::Queue>
+
+  myqueue.issues #<YandexTracker::Collections::Issues>
+
+  issue = myqueue.issues.create(summary: "zxc")
+  comment = issue.comments.create(text: "ok")
+
+  issue.attachments.create(File.open("Screenshot.png"))
+
+  unattached_file = client.attachments.create(File.open("Screenshot.png"))
+  comment.create(text: "More details", attachmentIds: [temp_attachment.id])
+
+  issue.transitions.list
+  issue.transition('wont_fix', comment: 'wae')
+  issue.transition('reopen', comment: 'no')
+  issue.transition('close', resolution: 'wontFix')
+
+  client.issues.list
+  client.issues(queue: "MYQUEUE").list
+  attachments = client.attachments(issue: "MYQUEUE-1").list
+  attachments.first.download
+
+  client.comments(issue: "MYQUEUE-1").create(text: "hello")
+
+  issue = client.issues.search({
+    filter: { queue: "TEST", status: "open"}},
+    expand: "attachments"
+  ).first
+
+  issue.createdBy
+  issue.createdBy.expand
+
+  issue.attachments
+  issue.data
+
+  client.issues.import({
+    queue: "TEST",
+    summary: "Test",
+    createdAt: "2017-08-29T12:34:41.740+0000",
+    createdBy: "username",
+    ...
+  })
+
+  client.categories.list
+  client.categories.create(
+    name: { en: "My Category", ru: "Моя Категория" },
+    order: 1
+  )
+
+  client.fields.create(
+    name: { en: "My Field", ru: "Моe поле" },
+    id: "myglobalfield",
+    type: "ru.yandex.startrek.core.fields.StringFieldType",
+    category: "0000000000000003********"
+  )
+
+  myqueue.local_fields.list
+  myqueue.local_fields.create(
+    name: { en: "My Field", ru: "Моe поле" },
+    id: "myglobalfield",
+    category: "0000000000000003********",
+    type: "ru.yandex.startrek.core.fields.StringFieldType"
+  )
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/yandex_tracker/auth.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "base64"
+require "faraday"
+
+module YandexTracker
+  #
+  # Handles OAuth authentication flow and token management
+  #
+  class Auth
+    AUTH_URL = "https://oauth.yandex.ru/token"
+
+    class << self
+      def exchange_code(code)
+        raise ArgumentError, "code is required" if code.nil? || code.empty?
+
+        response = make_request(grant_type: "authorization_code", code: code)
+        update_configuration(response)
+        response
+      end
+
+      def refresh_token
+        validate_oauth_config!
+        refresh_token = YandexTracker.configuration.refresh_token
+        raise ArgumentError, "refresh_token is required" if refresh_token.nil? || refresh_token.empty?
+
+        response = make_request(grant_type: "refresh_token", refresh_token: refresh_token)
+        update_configuration(response)
+        response
+      end
+
+      private
+
+      def validate_oauth_config!
+        config = YandexTracker.configuration
+
+        raise Errors::AuthError, "client_id is required" if config.client_id.nil? || config.client_id.empty?
+        raise Errors::AuthError, "client_secret is required" if config.client_secret.nil? || config.client_secret.empty?
+      end
+
+      def make_request(params)
+        response = connection.post("", params)
+        handle_response(response)
+      rescue Faraday::Error => e
+        raise Errors::AuthError, "Authentication failed: #{e.message}"
+      end
+
+      def connection
+        Faraday.new(url: AUTH_URL) do |f|
+          f.request :url_encoded
+          f.response :json
+          f.headers["Authorization"] = "Basic #{basic_auth}"
+        end
+      end
+
+      def basic_auth
+        credentials = "#{YandexTracker.configuration.client_id}:#{YandexTracker.configuration.client_secret}"
+        Base64.strict_encode64(credentials)
+      end
+
+      def handle_response(response)
+        return response.body if response.success?
+
+        raise Errors::AuthError, Errors.format_message(response.body)
+      end
+
+      def update_configuration(response_body)
+        YandexTracker.configuration.update_tokens(
+          access_token: response_body["access_token"],
+          refresh_token: response_body["refresh_token"],
+          expires_in: response_body["expires_in"]
+        )
+      end
+    end
+  end
+end

data/lib/yandex_tracker/client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "faraday/retry"
+
+module YandexTracker
+  #
+  # API client
+  #
+  class Client
+    BASE_URL = "https://api.tracker.yandex.net/v2"
+
+    attr_reader :conn, :multipart_conn
+
+    def initialize
+      YandexTracker.configuration.validate!
+      setup_connections
+    end
+
+    def setup_connections
+      @conn = make_client(:json)
+      @multipart_conn = make_client(:multipart)
+    end
+
+    def users
+      Collections::Users.new(self)
+    end
+
+    def queues
+      Collections::Queues.new(self)
+    end
+
+    def issues(queue: nil)
+      Collections::Issues.new(self, queue)
+    end
+
+    def comments(issue: nil)
+      Collections::Comments.new(self, issue)
+    end
+
+    def attachments(issue: nil)
+      Collections::Attachments.new(self, issue)
+    end
+
+    def workflows
+      Collections::Workflows.new(self)
+    end
+
+    def resolutions
+      Collections::Resolutions.new(self)
+    end
+
+    def fields
+      Collections::Fields.new(self)
+    end
+
+    def categories
+      Collections::Categories.new(self)
+    end
+
+    private
+
+    def make_client(request)
+      Faraday.new(url: BASE_URL) do |f|
+        f.request request
+        f.response :json
+        f.request :retry, { max: 3, retry_statuses: [401, 409, 500, 502, 503, 504] }
+        f.adapter Faraday.default_adapter
+        f.headers.merge!(YandexTracker.configuration.additional_headers)
+        f.request :authorization, "Bearer", -> { ensure_fresh_token }
+      end
+    end
+
+    def ensure_fresh_token
+      configuration = YandexTracker.configuration
+
+      if configuration.can_refresh? && configuration.token_expired?
+        if configuration.can_perform_oauth?
+          YandexTracker::Auth.refresh_token
+        else
+          raise YandexTracker::Errors::AuthError,
+                "Token expired and unable to refresh (missing refresh_token or OAuth credentials)"
+        end
+      end
+      configuration.access_token
+    end
+  end
+end

data/lib/yandex_tracker/collections/attachments.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::Attachments
+    #
+    class Attachments < Base
+      def initialize(client, issue_id = nil, comment_id = nil)
+        super(client)
+        @resource = Resources::Attachment.new(client)
+        @issue_id = issue_id
+        @comment_id = comment_id
+      end
+
+      def create(file, **attributes)
+        response = if comment_id
+                     resource.create_for_comment(issue_id, comment_id, file, **attributes)
+                   elsif issue_id
+                     resource.create_for_issue(issue_id, file, **attributes)
+                   else
+                     resource.create(file, **attributes) # Create unattached file
+                   end
+        build_object(Objects::Attachment, response, { issue_id: issue_id })
+      end
+
+      def find(id)
+        response = resource.find(id)
+        build_object(Objects::Attachment, response, { issue_id: issue_id })
+      end
+
+      def list(**params)
+        params = params.merge(issue: issue_id) if issue_id
+        response = resource.list(issue_id, **params)
+        build_objects(Objects::Attachment, response, { issue_id: issue_id })
+      end
+
+      private
+
+      attr_reader :resource, :issue_id, :comment_id
+    end
+  end
+end

data/lib/yandex_tracker/collections/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::Base
+    #
+    class Base
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      def inspect
+        "#<#{self.class.name}>"
+      end
+
+      private
+
+      def build_object(klass, data, context = {})
+        klass.new(client, data, context)
+      end
+
+      def build_objects(klass, data, context = {})
+        data.map { |item| build_object(klass, item, context) }
+      end
+    end
+  end
+end

data/lib/yandex_tracker/collections/categories.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::Categories
+    #
+    class Categories < Base
+      def initialize(client)
+        super
+        @resource = Resources::Category.new(client)
+      end
+
+      def find(id)
+        response = resource.find(id)
+        build_object(Objects::Category, response)
+      end
+
+      def create(**attributes)
+        response = resource.create(**attributes)
+        build_object(Objects::Category, response)
+      end
+
+      def list(**params)
+        response = resource.list(**params)
+        build_objects(Objects::Category, response)
+      end
+
+      private
+
+      attr_reader :resource
+    end
+  end
+end

data/lib/yandex_tracker/collections/comments.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::Comments
+    #
+    class Comments < Base
+      attr_reader :issue_id
+
+      def initialize(client, issue_id)
+        raise ArgumentError, "issue_id is required" if issue_id.nil?
+
+        super(client)
+        @resource = Resources::Comment.new(client)
+        @issue_id = issue_id
+      end
+
+      def find(id)
+        response = resource.find(issue_id, id)
+        build_object(Objects::Comment, response, { issue_id: issue_id })
+      end
+
+      def create(**attributes)
+        response = resource.create(issue_id, **attributes)
+        build_object(Objects::Comment, response, { issue_id: issue_id })
+      end
+
+      def list(**params)
+        response = resource.list(issue_id, **params)
+        build_objects(Objects::Comment, response, { issue_id: issue_id })
+      end
+
+      def update(comment, **attributes)
+        response = resource.update(issue_id, comment.id, **attributes)
+        build_object(Objects::Comment, response, { issue_id: issue_id })
+      end
+
+      private
+
+      attr_reader :resource
+    end
+  end
+end

data/lib/yandex_tracker/collections/fields.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::Fields
+    #
+    class Fields < Base
+      def initialize(client)
+        super
+        @resource = Resources::Field.new(client)
+      end
+
+      def find(id)
+        response = resource.find(id)
+        build_object(Objects::Field, response)
+      end
+
+      def create(**attributes)
+        response = resource.create(**attributes)
+        build_object(Objects::Field, response)
+      end
+
+      def list(**params)
+        response = resource.list(**params)
+        build_objects(Objects::Field, response)
+      end
+
+      def categories
+        @categories ||= Categories.new(client)
+      end
+
+      private
+
+      attr_reader :resource
+    end
+  end
+end

data/lib/yandex_tracker/collections/issues.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::Issues
+    #
+    class Issues < Base
+      attr_reader :queue_id
+
+      def initialize(client, queue_id = nil)
+        super(client)
+        @resource = Resources::Issue.new(client)
+        @queue_id = queue_id
+      end
+
+      def find(id)
+        response = resource.find(id)
+        build_object(Objects::Issue, response, { queue_id: queue_id })
+      end
+
+      def create(**attributes)
+        attributes = attributes.merge(queue: queue_id) if queue_id
+        response = resource.create(**attributes)
+        build_object(Objects::Issue, response, { queue_id: queue_id })
+      end
+
+      def list(**params)
+        params = params.merge(queue: queue_id) if queue_id
+        response = resource.list(**params)
+        build_objects(Objects::Issue, response, { queue_id: queue_id })
+      end
+
+      def search(body = {}, **query_params)
+        response = resource.search(body, **query_params)
+        build_objects(Objects::Issue, response, { queue_id: queue_id })
+      end
+
+      def import(body = {}, **query_params)
+        response = resource.import(body, **query_params)
+        build_objects(Objects::Issue, response, { queue_id: queue_id })
+      end
+
+      private
+
+      attr_reader :resource
+    end
+  end
+end

data/lib/yandex_tracker/collections/local_fields.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::LocalFields
+    #
+    class LocalFields < Base
+      attr_reader :queue_id
+
+      def initialize(client, queue_id)
+        raise ArgumentError, "queue_id is required" if queue_id.nil?
+
+        super(client)
+        @resource = Resources::LocalField.new(client)
+        @queue_id = queue_id
+      end
+
+      def find(key)
+        response = resource.find(queue_id, key)
+        build_object(Objects::LocalField, response)
+      end
+
+      def create(**attributes)
+        response = resource.create(queue_id, **attributes)
+        build_object(Objects::LocalField, response)
+      end
+
+      def list(**params)
+        response = resource.list(queue_id, **params)
+        build_objects(Objects::LocalField, response)
+      end
+
+      private
+
+      attr_reader :resource
+    end
+  end
+end

data/lib/yandex_tracker/collections/queues.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Collections
+    #
+    # Collections::Queues
+    #
+    class Queues < Base
+      def initialize(client)
+        super
+        @resource = Resources::Queue.new(client)
+      end
+
+      def find(id)
+        response = resource.find(id)
+        build_object(Objects::Queue, response)
+      end
+
+      def create(**attributes)
+        response = resource.create(**attributes)
+        build_object(Objects::Queue, response)
+      end
+
+      def list(**params)
+        response = resource.list(**params)
+        build_objects(Objects::Queue, response)
+      end
+
+      private
+
+      attr_reader :resource
+    end
+  end
+end