yandex_tracker 0.1.0

data/lib/yandex_tracker/collections/resolutions.rb

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

data/lib/yandex_tracker/collections/users.rb

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

data/lib/yandex_tracker/collections/workflows.rb

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

data/lib/yandex_tracker/configuration.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  #
+  # Handles API client configuration and validation
+  #
+  class Configuration
+    attr_accessor :client_id, :client_secret,
+                  :cloud_org_id, :org_id,
+                  :access_token, :refresh_token
+
+    def validate!
+      validate_org_configuration!
+      validate_auth_configuration!
+    end
+
+    def update_tokens(access_token:, refresh_token:, expires_in:)
+      @access_token = access_token
+      @refresh_token = refresh_token
+      @token_expires_at = Time.now + expires_in
+    end
+
+    def token_expired?
+      return false unless @token_expires_at
+
+      Time.now >= (@token_expires_at - 300)
+    end
+
+    def can_refresh?
+      !@refresh_token.nil?
+    end
+
+    def additional_headers
+      headers = {}
+      headers["X-Cloud-Org-ID"] = cloud_org_id if cloud_org_id
+      headers["X-Org-Id"] = org_id if org_id && !cloud_org_id
+      headers
+    end
+
+    def can_perform_oauth?
+      valid_oauth_auth?
+    end
+
+    private
+
+    def validate_org_configuration!
+      return if cloud_org_id || org_id
+
+      raise Errors::ConfigurationError, "Required configuration missing: either cloud_org_id or org_id must be set"
+    end
+
+    def validate_auth_configuration!
+      return if valid_token_auth? || valid_oauth_auth?
+
+      raise Errors::ConfigurationError, "Either access_token or (client_id + client_secret) must be set"
+    end
+
+    def valid_token_auth?
+      access_token
+    end
+
+    def valid_oauth_auth?
+      client_id && client_secret
+    end
+  end
+end

data/lib/yandex_tracker/errors.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  #
+  # Custom error classes and error formatting for the API client
+  #
+  module Errors
+    class ApiError < StandardError; end
+    class AuthError < ApiError; end
+    class Unauthorized < ApiError; end
+    class NotFound < ApiError; end
+    class TimeoutError < ApiError; end
+    class ConnectionError < ApiError; end
+    class ConfigurationError < StandardError; end
+    class Error < StandardError; end
+    class ArgumentError < Error; end
+    class ResourceError < Error; end
+    class ContextError < Error; end
+
+    module_function
+
+    def format_message(body)
+      return body.to_s unless body.is_a?(Hash)
+
+      # TODO: {"errors"=>{"type"=>"Требуется параметр.", "category"=>"Требуется параметр."}, \
+      # "errorsData"=>{}, "errorMessages"=>[], "statusCode"=>422}
+      body["errorMessages"]&.join(", ") || body["message"] || body.to_s
+    end
+  end
+end

data/lib/yandex_tracker/objects/attachment.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Attachment
+    #
+    class Attachment < Base
+      def download
+        resource.get(data["content"])
+      end
+
+      def thumbnail
+        resource.get(data["thumbnail"])
+      end
+
+      private
+
+      def resource
+        @resource ||= Resources::Attachment.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Base
+    #
+    class Base
+      attr_reader :client, :data, :context
+
+      def initialize(client, data, context = {})
+        @client = client
+        @data = data
+        @context = context
+        refresh_from(data)
+      end
+
+      def id
+        data["id"]
+      end
+
+      def method_missing(name, *args)
+        key = name.to_s
+        return wrap_value(data[key]) if data.key?(key)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        data.key?(name.to_s) || super
+      end
+
+      # fetch full object from .self
+      def expand
+        return self unless data["self"]
+
+        response = client.conn.get(data["self"]).body
+        refresh_from(response)
+      end
+
+      protected
+
+      def refresh_from(new_data)
+        @data = new_data
+        self
+      end
+
+      private
+
+      def wrap_value(value)
+        case value
+        when Hash then wrap_hash(value)
+        when Array then value.map { |v| wrap_value(v) }
+        else value
+        end
+      end
+
+      def wrap_hash(hash)
+        return hash unless hash["self"]
+
+        resource_type = hash["self"].split("/").last(2).first
+        object_class = classify(resource_type)
+
+        return hash unless object_class
+
+        object_class.new(client, hash, context)
+      end
+
+      def classify(type)
+        class_name = type.split(/(?=[A-Z])/).map(&:capitalize).join.chomp("s")
+        Objects.const_get(class_name)
+      rescue NameError
+        nil
+      end
+
+      def build_objects(klass, data)
+        data.map { |item| klass.new(client, item, context) }
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/category.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Category
+    #
+    class Category < Base
+      private
+
+      def resource
+        @resource ||= Resources::Category.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/comment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Comment
+    #
+    class Comment < Base
+      def attachments
+        @attachments ||= Collections::Attachments.new(client, context[:issue_id], comment_id: id)
+      end
+
+      def update(**attributes)
+        raise ArgumentError, "issue_id is required" unless context[:issue_id]
+
+        response = resource.update(context[:issue_id], id, **attributes)
+        refresh_from(response)
+      end
+
+      private
+
+      def resource
+        @resource ||= Resources::Comment.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/field.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Field
+    #
+    class Field < Base
+      private
+
+      def resource
+        @resource ||= Resources::Field.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/issue.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Issue
+    #
+    class Issue < Base
+      def comments
+        @comments ||= Collections::Comments.new(client, id)
+      end
+
+      def attachments
+        if data["attachments"]
+          build_objects(Objects::Attachment, data["attachments"])
+        else
+          Collections::Attachments.new(client, id)
+        end
+      end
+
+      def update(**attributes)
+        response = resource.update(id, attributes)
+        refresh_from(response)
+      end
+
+      def transition(transition_id, **attributes)
+        resource.transition(id, transition_id, **attributes)
+      end
+
+      private
+
+      def resource
+        @resource ||= Resources::Issue.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/local_field.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::LocalField
+    #
+    class LocalField < Base
+      private
+
+      def resource
+        @resource ||= Resources::LocalField.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/queue.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Queue
+    #
+    class Queue < Base
+      def issues
+        @issues ||= Collections::Issues.new(client, id)
+      end
+
+      def update(**attributes)
+        response = resource.update(id, attributes)
+        refresh_from(response)
+      end
+
+      def local_fields
+        @local_fields ||= Collections::LocalFields.new(client, id)
+      end
+
+      private
+
+      def resource
+        @resource ||= Resources::Queue.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/resolution.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Resolution
+    #
+    class Resolution < Base
+      private
+
+      def resource
+        @resource ||= Resources::Resolution.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/user.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::User
+    #
+    class User < Base
+      private
+
+      def resource
+        @resource ||= Resources::User.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/objects/workflow.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Objects
+    #
+    # Objects::Workflow
+    #
+    class Workflow < Base
+      private
+
+      def resource
+        @resource ||= Resources::Workflow.new(client)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/resources/attachment.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Resources
+    #
+    # Resources::Attachment
+    #
+    class Attachment < Base
+      # Create unattached file
+      def create(file, **attributes)
+        upload("attachments", file, attributes)
+      end
+
+      # Upload file directly to issue
+      def create_for_issue(issue_id, file, **attributes)
+        upload("issues/#{issue_id}/attachments", file, attributes)
+      end
+
+      # Upload file directly to comment
+      def create_for_comment(issue_id, comment_id, file, **attributes)
+        upload("issues/#{issue_id}/comments/#{comment_id}/attachments", file, attributes)
+      end
+
+      def find(id)
+        get("attachments/#{id}")
+      end
+
+      def list(issue_id, **params)
+        get("issues/#{issue_id}/attachments", params)
+      end
+
+      private
+
+      def upload(path, file, attributes)
+        form = {
+          file: Faraday::Multipart::FilePart.new(
+            file.path,
+            mime_type(file),
+            File.basename(file)
+          )
+        }.merge(attributes)
+
+        handle_response client.multipart_conn.post(path, form)
+      end
+
+      def mime_type(file)
+        return file.content_type if file.respond_to?(:content_type)
+
+        require "mime/types"
+        MIME::Types.type_for(file.path).first&.content_type || "application/octet-stream"
+      end
+    end
+  end
+end

data/lib/yandex_tracker/resources/base.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module YandexTracker
+  module Resources
+    #
+    # Resources::Base
+    #
+    class Base
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      def get(path, params = {}, query_params = {})
+        handle_response client.conn.get(prepare_path(path, query_params), params)
+      end
+
+      def post(path, body = {}, query_params = {})
+        handle_response client.conn.post(prepare_path(path, query_params), body)
+      end
+
+      def put(path, body = {}, query_params = {})
+        handle_response client.conn.put(prepare_path(path, query_params), body)
+      end
+
+      def patch(path, body = {}, query_params = {})
+        handle_response client.conn.patch(prepare_path(path, query_params), body)
+      end
+
+      def delete(path, params = {}, query_params = {})
+        handle_response client.conn.delete(prepare_path(path, query_params), params)
+      end
+
+      private
+
+      def handle_response(response)
+        return response.body if response.success?
+
+        handle_error_response(response)
+      rescue Faraday::TimeoutError
+        raise Errors::TimeoutError, "Request timed out"
+      rescue Faraday::ConnectionFailed => e
+        raise Errors::ConnectionError, "Connection failed: #{e.message}"
+      end
+
+      def handle_error_response(response)
+        puts response.body
+        case response.status
+        when 401, 403 then raise Errors::Unauthorized, Errors.format_message(response.body)
+        when 404 then raise Errors::NotFound, Errors.format_message(response.body)
+        else raise Errors::ApiError, Errors.format_message(response.body)
+        end
+      end
+
+      def encode_path(path)
+        URI.encode_www_form_component(path.to_s)
+      rescue URI::InvalidURIError => e
+        raise Errors::ApiError, "Invalid path: #{e.message}"
+      end
+
+      def prepare_path(path, query_params = {})
+        segments = path.split("/").map { |segment| encode_path(segment) }
+        path = segments.join("/")
+        path = "#{path}?#{URI.encode_www_form(query_params)}" unless query_params.empty?
+        path
+      end
+    end
+  end
+end

data/lib/yandex_tracker/resources/category.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Resources
+    #
+    # Resources::Category
+    #
+    class Category < Base
+      def list(**params)
+        get("fields/categories", params)
+      end
+
+      def create(**attributes)
+        post("fields/categories", attributes)
+      end
+
+      def find(id)
+        get("fields/categories/#{id}")
+      end
+    end
+  end
+end

data/lib/yandex_tracker/resources/comment.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Resources
+    #
+    # Resources::Comment
+    #
+    class Comment < Base
+      def create(issue_id, **attributes)
+        post("issues/#{issue_id}/comments", attributes)
+      end
+
+      def update(issue_id, comment_id, **attributes)
+        patch("issues/#{issue_id}/comments/#{comment_id}", attributes)
+      end
+
+      def list(issue_id, **params)
+        get("issues/#{issue_id}/comments", params)
+      end
+    end
+  end
+end

data/lib/yandex_tracker/resources/field.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module YandexTracker
+  module Resources
+    #
+    # Resources::Field
+    #
+    class Field < Base
+      def list(**params)
+        get("fields", params)
+      end
+
+      def create(**attributes)
+        post("fields", attributes)
+      end
+
+      def find(id)
+        get("fields/#{id}")
+      end
+    end
+  end
+end