ticket_abstractor_client 1.29.0 → 2.0.0

data/lib/ticket_abstractor_client/jira/attachment.rb

@@ -0,0 +1,42 @@
+module TicketAbstractorClient
+  module Jira
+    class Attachment < Base::Attachment
+      attr_accessor :ticket_id, :endpoint, :project
+
+      class << self
+        def fetch_by_id_and_name(id, name, endpoint)
+          file_path = download_attachment(id, name, endpoint)
+          new(file_path: file_path, endpoint: endpoint)
+        end
+
+        def fetch_by_ticket_id(ticket_id, endpoint)
+          ticket = Client.new(endpoint).get_ticket_by_id(ticket_id: ticket_id, fields: :attachment)
+
+          ticket['fields']['attachment'].each_with_object([]) do |hash, attachments|
+            attachment = fetch_by_id_and_name(hash['id'], hash['filename'], endpoint)
+            attachment.ticket_id = ticket_id
+            attachments << attachment
+          end
+        end
+        alias_method :fetch, :fetch_by_ticket_id
+
+        protected
+
+        def download_attachment(id, name, endpoint)
+          file_content = Client.new(endpoint).get_attachment(id: id, name: name)
+          save_content(file_content, "#{id}_#{name}")
+        end
+      end
+
+      def initialize(opts)
+        super(opts)
+        @ticket_id, @endpoint, @project = opts.values_at(:ticket_id, :endpoint, :project)
+      end
+
+      def sync!
+        response = Client.new(@endpoint).create_attachment(self)
+        @external_created_at = response.first['created']
+      end
+    end
+  end
+end

data/lib/ticket_abstractor_client/jira/client.rb

@@ -0,0 +1,83 @@
+module TicketAbstractorClient
+  module Jira
+    class Client < Base::Client
+      include Jira::ParamsBuilder
+
+      def initialize(endpoint = 'tp')
+        super()
+        @jira_endpoint = endpoint
+      end
+
+      def create_attachment(attachment)
+        args, params = build_attachment_params(attachment)
+        post(__method__, args, params)
+      end
+
+      def create_comment(comment)
+        post(__method__, build_comment_params(comment))
+      end
+
+      def create_ticket(ticket)
+        post(__method__, build_ticket_params(ticket))
+      end
+
+      def endpoints
+        get(__method__)
+      end
+
+      def get_all_fields
+        get(__method__)
+      end
+
+      def get_attachment(opts)
+        get(__method__, opts)
+      end
+
+      def get_comments(opts)
+        get(__method__, opts)
+      end
+
+      def get_fields_by_project(opts)
+        get(__method__, opts)
+      end
+
+      def get_ticket_by_id(opts)
+        get(__method__, opts)
+      end
+
+      def get_ticket_status(opts)
+        get(__method__, build_status_params(opts))
+      end
+
+      def get_tickets_by_jql(opts)
+        get(__method__, opts)
+      end
+
+      def get_tickets_statuses(opts)
+        get(__method__, opts)
+      end
+
+      def update_ticket(ticket)
+        post(__method__, build_ticket_params(ticket))
+      end
+
+      def transit_ticket(ticket)
+        post(__method__, build_transitions_params(ticket))
+      end
+
+      def transitions_list(ticket_id)
+        get(__method__, { ticket_id: ticket_id })
+      end
+
+      protected
+
+      def get(path, args = {}, params = {})
+        super("jira/#{path}", args, params.merge(jira_endpoint: @jira_endpoint))
+      end
+
+      def post(path, args = {}, params = {})
+        super("jira/#{path}", args, params.merge(jira_endpoint: @jira_endpoint))
+      end
+    end
+  end
+end

data/lib/ticket_abstractor_client/jira/comment.rb

@@ -0,0 +1,35 @@
+module TicketAbstractorClient
+  module Jira
+    class Comment < Base::Comment
+      attr_accessor :ticket_id, :endpoint, :project, :author_display_name
+
+      def self.fetch(ticket_id, endpoint)
+        comments_list = Client.new(endpoint).get_comments(ticket_id: ticket_id)
+        comments_list['comments'].map do |raw_comment|
+          new(
+            author: raw_comment['author']['name'],
+            author_display_name: raw_comment['author']['displayName'],
+            body: raw_comment['body'],
+            external_created_at: raw_comment['created'],
+            ticket_id: ticket_id,
+            endpoint: endpoint
+          )
+        end
+      end
+
+      def initialize(opts)
+        super(opts)
+        @author_display_name = opts[:author_display_name]
+        @ticket_id, @endpoint, @project = opts.values_at(:ticket_id, :endpoint, :project)
+      end
+
+      def sync!
+        created_comment_hash = Client.new(@endpoint).create_comment(self)
+        @author = created_comment_hash['author']['name']
+        @author_display_name = created_comment_hash['author']['displayName']
+        @external_created_at = created_comment_hash['created']
+        self.set_data_hash!
+      end
+    end
+  end
+end

data/lib/ticket_abstractor_client/jira/errors.rb

@@ -0,0 +1,25 @@
+module TicketAbstractorClient
+  module Jira
+    module Errors
+      class BaseError < Base::Errors::BaseError; end
+      class NotImplementedError < BaseError; end
+      class ConfigurationError < Base::Errors::ConfigurationError; end
+      class UnexpectedError < Base::Errors::UnexpectedError; end
+
+      class AttachmentArgumentError < Base::Errors::AttachmentArgumentError; end
+      class CommentArgumentError < Base::Errors::CommentArgumentError; end
+      class ClientArgumentError < Base::Errors::ClientArgumentError; end
+      class TicketArgumentError < Base::Errors::TicketArgumentError; end
+
+      class AttachmentError < Base::Errors::AttachmentError; end
+      class CommentError < Base::Errors::CommentError; end
+      class TicketError < Base::Errors::TicketError; end
+
+      class ConnectionError < Base::Errors::ConnectionError; end
+      class NotFoundError < Base::Errors::NotFoundError; end
+      class ParseError < Base::Errors::ParseError; end
+      class RequsetFormatError < Base::Errors::RequsetFormatError; end
+      class AccessError < Base::Errors::AccessError; end
+    end
+  end
+end

data/lib/ticket_abstractor_client/jira/fields_meta.rb

@@ -0,0 +1,36 @@
+module TicketAbstractorClient
+  module Jira
+    class FieldsMeta < Hash
+      attr_accessor :endpoint
+      attr_reader :updated_at
+
+      def initialize(endpoint)
+        super()
+        @endpoint = endpoint
+        update!
+      end
+
+      def update!
+        get_meta_data
+        update(@meta_data)
+      end
+
+      def expired?
+        expiration_period = TicketAbstractorClient.configuration.jira_meta_expiration_period
+        (Time.now.to_i - @updated_at) > expiration_period
+      end
+
+      private
+
+      def get_meta_data
+        raw_meta_data = Client.new(@endpoint).get_all_fields
+        @meta_data = filter_meta_data(raw_meta_data)
+        @updated_at = Time.now.to_i
+      end
+
+      def filter_meta_data(raw_meta_data)
+        raw_meta_data.each_with_object({}) { |field, meta| meta[field['id']] = field['schema'] }
+      end
+    end
+  end
+end

data/lib/ticket_abstractor_client/jira/params_builder.rb

@@ -0,0 +1,96 @@
+module TicketAbstractorClient
+  module Jira
+    module ParamsBuilder
+      extend ActiveSupport::Concern
+
+      def build_attachment_params(attachment)
+        [
+          { ticket_id: attachment.ticket_id },
+          { attachments: [File.new(attachment.file_path, 'rb')] }
+        ]
+      end
+
+      def build_comment_params(comment)
+        { ticket_id: comment.ticket_id, comment: { body: comment.body } }
+      end
+
+      def build_ticket_params(ticket)
+        params_hash = { ticket_params: {} }
+        params_hash[:ticket_id] = ticket.ticket_id if ticket.ticket_id.present?
+
+        fields = ticket.fields.each_with_object({}) do |(field_name, field_value), fields|
+          value = jira_field_value(ticket.endpoint, field_name, field_value)
+          fields[field_name] = value
+        end
+
+        params_hash[:ticket_params].merge!(fields: fields)
+        params_hash
+      end
+
+      def build_transitions_params(ticket)
+        new_status = ticket.status
+        transition = ticket.available_statuses[new_status]
+
+        raise Errors::ClientArgumentError, "Status '#{new_status}' is incorrect or prohibited" if transition.blank?
+
+        { ticket_id: ticket.ticket_id, transition_params: { transition: { id: transition } } }
+      end
+
+      def jira_field_value(endpoint, name, value)
+        field_meta = fields_meta(endpoint)[name]
+        return unless field_meta
+
+        if field_meta['system']          # system fields mapping
+          case field_meta['type']
+            when 'project'
+              { key: value }
+            when 'string'
+              value
+            when 'datetime'
+              Time.parse(value).to_s(:jira_iso8601) rescue value
+            when 'date'
+              Date.parse(value).to_s rescue value
+            when 'number'
+              value.to_i
+            when 'array'
+              Array.wrap(value)
+            else # when 'user', 'status', 'issuetype', 'priority'
+              { name: value }
+          end
+
+        elsif custom_type = field_meta['custom']     # custom fields mapping
+          case custom_type
+            when /(:cascadingselect|:radiobuttons|:select)\Z/
+              { value: value }
+            when /:datepicker\Z/
+              Date.parse(value).to_s rescue value
+            when /:datetime\Z/
+              Time.parse(value).to_s(:jira_iso8601) rescue value
+            when /(:freetextfield|:textfield|:textarea|:url)\Z/
+              value
+            when /(:grouppicker|:singleversionpicker|:userpicker)\Z/
+              { name: value }
+            when /(:numberfield|:float)\Z/
+              value.to_i
+            when /:projectpicker\Z/
+              { key: value }
+            when /:labels\Z/
+              Array.wrap(value)
+            when /(:multigrouppicker|:multiuserpicker|:versionpicker)\Z/
+              Array.wrap(value).map { |v| { name: v } }
+            when /:multiselect\Z/
+              Array.wrap(value).map { |v| { value: v } }
+            else
+              raise Errors::ClientArgumentError, "Unknown customfield type #{custom_type}"
+          end
+        end
+      end
+
+      def fields_meta(endpoint)
+        meta = TicketAbstractorClient.configuration.jira_fields_meta[endpoint.to_sym]
+        meta.update! if meta.expired?
+        meta
+      end
+    end
+  end
+end

data/lib/ticket_abstractor_client/jira/ticket.rb

@@ -0,0 +1,131 @@
+module TicketAbstractorClient
+  module Jira
+    class Ticket < Base::Ticket
+
+      def self.fetch_by_id(opts)
+        opts[:fields] ||= []
+        opts[:fields] += %w(-attachment -comment)
+        fetch(:by_id, opts).first
+      end
+
+      def self.fetch_tickets_by_jql(opts)
+        fetch(:by_jql, opts)
+      end
+
+      def initialize(opts)
+        super(opts)
+        @fields['project'] = @project if @project.present?
+        @status = @fields.delete('status')
+      end
+
+      def add_attachment(attachment)
+        @attachments ||= []
+        @attachments << Attachment.new(attachment.merge!(ticket_id: @ticket_id, endpoint: @endpoint))
+        @changes[:new_attachments] += 1
+        self
+      end
+
+      def add_comment(comment)
+        @comments ||= []
+        @comments << Comment.new(comment.merge!(ticket_id: @ticket_id, endpoint: @endpoint))
+        @changes[:new_comments] += 1
+        self
+      end
+
+      def attachments
+        return @attachments if @attachments.present?
+
+        return [] if @ticket_id.blank? && @attachments.blank?
+
+        @attachments = Attachment.fetch(@ticket_id, @endpoint)
+      end
+
+      def available_statuses
+        raw_response = Client.new(@endpoint).transitions_list(@ticket_id)
+        raw_response['transitions'].each_with_object({}) do |transition, transitions_map|
+          transitions_map[transition['to']['name']] = transition['id']
+        end
+      end
+
+      def comments
+        return @comments if @comments.present?
+
+        return [] if @ticket_id.blank? && @comments.blank?
+
+        @comments = Comment.fetch(@ticket_id, @endpoint)
+      end
+
+      def reload!
+        ticket = Ticket.fetch_by_id(ticket_id: @ticket_id, project: @project, endpoint: @endpoint)
+        @fields = ticket.fields
+        @status = ticket.status
+      end
+
+      def sync!
+        raise(Errors::TicketArgumentError, 'No changes to apply') unless self.any_changes?
+
+        return self.create_ticket if @changes[:create]
+
+        update_ticket if @changes[:update]
+        update_status if @changes[:new_status]
+        sync_comments unless @changes[:new_comments].zero?
+        sync_attachments unless @changes[:new_attachments].zero?
+        self.reload!
+        self.reset_changes!
+      end
+
+      def updated_at
+        @fields['updated']
+      end
+
+      private
+
+      def self.fetch(selektor, opts)
+        methods_map = { by_id: :get_ticket_by_id, by_jql: :get_tickets_by_jql }
+        opts = opts.with_indifferent_access
+        endpoint = opts.delete(:endpoint)
+        raw_tickets = Client.new(endpoint).public_send(methods_map.fetch(selektor.to_sym), opts)
+        raw_tickets = raw_tickets['issues'] if raw_tickets.key?('issues')
+
+        Array.wrap(raw_tickets).map do |raw_ticket|
+          fields = filter_fields(raw_ticket['fields'])
+          ticket = new(ticket_id: raw_ticket['key'], endpoint: endpoint, fields: fields)
+          ticket.reset_changes!
+          ticket
+        end
+      end
+
+      def self.filter_fields(fields)
+        fields.extract!('attachment', 'comment')
+        filter_fields_klass = TicketAbstractorClient.configuration.jira_fields_filter_class
+
+        return fields if filter_fields_klass.blank?
+
+        filter_fields_klass.new(fields).filter_fields
+      end
+
+      def create_ticket
+        response = Client.new(@endpoint).create_ticket(self)
+        @ticket_id = response['key']
+        self.reload!
+        self.reset_changes!
+      end
+
+      def update_status
+        Client.new(@endpoint).transit_ticket(self)
+      end
+
+      def update_ticket
+        Client.new(@endpoint).update_ticket(self)
+      end
+
+      def sync_attachments
+        @attachments.last(@changes[:new_attachments]).map(&:sync!)
+      end
+
+      def sync_comments
+        @comments.last(@changes[:new_comments]).map(&:sync!)
+      end
+    end
+  end
+end