ticket-replicator 0.1.1

data/lib/ticket/replicator/row_loader.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/jira_project"
+
+module Ticket
+  class Replicator
+    class RowLoader
+      def self.run_on(jira_project, row)
+        new(jira_project, row).run
+      end
+
+      private_class_method :new
+
+      attr_reader :jira_project, :row
+
+      def initialize(jira_project, row)
+        @jira_project = jira_project
+        @row = row
+      end
+
+      def run
+        save_ticket
+        transition_ticket_to_the_expected_status
+      end
+
+      def ticket_previously_replicated?
+        jira_project.replicated_tickets.key?(id)
+      end
+
+      def save_ticket
+        return unless ticket_fields_need_to_be_updated?
+
+        ticket.jira_ticket.save!({
+                                   fields: {
+                                     project: { key: jira_project.project_key },
+                                     issuetype: { name: jira_project.ticket_type_name },
+                                     #                              resolution: { name: resolution },
+                                     priority: { name: priority },
+                                     # implementation_team: { name: team },
+                                     summary: summary
+                                   }
+                                 })
+
+        ticket.jira_ticket.fetch
+      end
+
+      def ticket_fields_need_to_be_updated?
+        !ticket_previously_replicated? || ticket_fields_changed?
+      end
+
+      def ticket_fields_changed?
+        fields_to_save.any? { |field| ticket.send(field) != send(field) }
+      end
+
+      def fields_to_save
+        %i[summary priority]
+      end
+
+      def transition_ticket_to_the_expected_status
+        ticket.transition_to(status)
+      end
+
+      def ticket
+        @ticket ||=
+          if ticket_previously_replicated?
+            fetch_ticket
+          else
+            create_ticket
+          end
+      end
+
+      def fetch_ticket
+        jira_project.replicated_tickets.fetch(id)
+      end
+
+      def create_ticket
+        Replicator::Ticket.new(jira_project.jira_auto_tool, jira_project.jira_client.Issue.build)
+      end
+
+      private
+
+      def method_missing(name, *args)
+        if field_to_load?(name)
+          row.fetch(name) { |key| raise "No value found for #{key.inspect} in #{row.inspect}" }
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, *args)
+        field_to_load?(name) || super
+      end
+
+      def field_to_load?(field)
+        fields_to_load.include?(field)
+      end
+
+      def fields_to_load
+        self.class.fields_to_load
+      end
+
+      class << self
+        def fields_to_load
+          @fields_to_load ||= RowTransformer.fields_to_transform.collect { |field| field.to_s.downcase.to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/ticket/replicator/row_transformer.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/replicated_summary"
+
+module Ticket
+  class Replicator
+    class RowTransformer
+      def self.run_on(extracted_row)
+        new(extracted_row).run
+      end
+
+      private_class_method :new
+
+      attr_reader :extracted_row
+
+      def initialize(extracted_row)
+        @extracted_row = extracted_row
+      end
+
+      def run
+        fields_to_transform.collect { |field| send("transformed_#{field.to_s.downcase}") }
+      end
+
+      def transformed_id
+        remapped_field_extracted_value_for :id
+      end
+
+      def transformed_status
+        mapped_value_for :status
+      end
+
+      def transformed_resolution
+        mapped_value_for :resolution, remapped_field_extracted_value_for(:status)
+      end
+
+      def transformed_priority
+        mapped_value_for :priority
+      end
+
+      def transformed_team
+        mapped_value_for :team
+      end
+
+      def transformed_summary
+        ReplicatedSummary.build(remapped_field_extracted_value_for(:id),
+                                remapped_field_extracted_value_for(:summary)).to_s
+      end
+
+      def fields_to_transform
+        self.class.fields_to_transform
+      end
+
+      def self.fields_to_transform
+        %i[ID Status Resolution Priority Team Summary]
+      end
+
+      def mapped_value_for(field, extracted_value = remapped_field_extracted_value_for(field))
+        mapping_for(field).fetch(extracted_value) do |key|
+          unless mapping_for(field)["defaults_to"] == "keep_original_value"
+            raise "No mapping found for #{field.inspect} = #{key.inspect} in #{mapping_for(field).inspect}"
+          end
+
+          extracted_value
+        end
+      end
+
+      def remapped_field_extracted_value_for(field)
+        remapped_field_extracted_row.fetch(remapped_field_key(field)) do |key|
+          raise "No value found for #{key.inspect} in #{remapped_field_extracted_row.inspect}"
+        end
+      end
+
+      def mappings
+        @mappings ||= YAML.safe_load_file(mapping_file_path, symbolize_names: false)
+      end
+
+      def remapped_field_extracted_row
+        @remapped_field_extracted_row ||= fields_to_transform.to_h do |field|
+          mapped_field_key = remapped_field_key(field)
+          [mapped_field_key, extracted_row_value_for(mapped_field_key)]
+        end
+      end
+
+      def extracted_field_mapping_for(field)
+        original_field = extracted_field_mapping.fetch(remapped_field_key(field)) do |key|
+          raise "No mapping found for #{key.inspect} in #{extracted_field_mapping.inspect}"
+        end
+
+        remapped_field_key(original_field)
+      end
+
+      def remapped_field_key(field)
+        field.to_s.downcase
+      end
+
+      def extracted_field_mapping
+        @extracted_field_mapping ||= mapping_for :field
+      end
+
+      def self.mapping_file_path
+        File.join("config", "ticket-replicator.mappings.yml")
+      end
+
+      private
+
+      def extracted_row_value_for(mapped_field_key)
+        extracted_field_mapping = extracted_field_mapping_for(mapped_field_key)
+
+        extracted_row.fetch(extracted_field_mapping) do
+          raise "No value found for #{mapped_field_key.inspect} as " \
+                "#{extracted_field_mapping.inspect} in #{extracted_row.inspect}"
+        end
+      end
+
+      def mapping_for(field)
+        mappings.fetch("#{field.to_s.downcase}_mapping") do |key|
+          raise "No mapping found for #{key.inspect} in #{mappings.inspect}"
+        end
+      end
+
+      def mapping_file_path
+        self.class.mapping_file_path
+      end
+    end
+  end
+end

data/lib/ticket/replicator/s_a_p_solution_manager_client.rb.DISABLED

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+class SAPSolutionManagerClient
+  HTTP_POST = Net::HTTP::Post::METHOD
+  HTTP_GET = Net::HTTP::Get::METHOD
+  HTTP_PUT = Net::HTTP::Put::METHOD
+  HTTP_DELETE = Net::HTTP::Delete::METHOD
+  CONTENT_TYPE_JSON = "application/json"
+  HTTP_OK = Net::HTTPSuccess::CODE
+  HTTP_CREATED = Net::HTTPCreated::CODE
+  HTTP_NO_CONTENT = Net::HTTPNoContent::CODE
+  API_AUTH_PATH = "/api/auth"
+  API_TICKETS_PATH = "/api/defect_tickets"
+  API_EXPORT_PATH = "/api/export/defect_tickets"
+  DEFAULT_TIMEOUT = 30
+  DEFAULT_FORMAT = "json"
+  DEFAULT_BASE_URL = "http://localhost:4567"
+
+  attr_reader :base_url, :auth_token
+
+  def initialize(base_url = DEFAULT_BASE_URL)
+    @base_url = base_url
+    @auth_token = nil
+  end
+
+  def authenticate(username, password)
+    uri = URI("#{@base_url}#{API_AUTH_PATH}")
+
+    request = Net::HTTP::Post.new(uri)
+    request.content_type = CONTENT_TYPE_JSON
+    request.body = { username: username, password: password }.to_json
+
+    response = send_request(uri, request)
+
+    if response.code == HTTP_OK
+      data = JSON.parse(response.body)
+      @auth_token = data["token"]
+      true
+    else
+      false
+    end
+  end
+
+  def get_tickets(params = {})
+    query_params = params.map { |k, v| "#{k}=#{v}" }.join("&")
+    uri = URI("#{@base_url}/api/defect_tickets")
+    uri.query = query_params unless query_params.empty?
+
+    request = Net::HTTP::Get.new(uri)
+    add_auth_header(request)
+
+    response = send_request(uri, request)
+
+    if response.code == "200"
+      JSON.parse(response.body)
+    else
+      handle_error_response(response)
+    end
+  end
+
+  def get_ticket(id)
+    uri = URI("#{@base_url}/api/defect_tickets/#{id}")
+
+    request = Net::HTTP.const_get(HTTP_GET).new(uri)
+    add_auth_header(request)
+
+    response = send_request(uri, request)
+
+    if response.code == HTTP_OK
+      JSON.parse(response.body)
+    else
+      handle_error_response(response)
+    end
+  end
+
+  def create_ticket(attributes)
+    uri = URI("#{@base_url}#{API_TICKETS_PATH}")
+
+    request = Net::HTTP::Post.new(uri)
+    request.content_type = "application/json"
+    request.body = attributes.to_json
+    add_auth_header(request)
+
+    response = send_request(uri, request)
+
+    if response.code == HTTP_CREATED
+      JSON.parse(response.body)
+    else
+      handle_error_response(response)
+    end
+  end
+
+  def update_ticket(id, attributes)
+    uri = URI("#{@base_url}/api/defect_tickets/#{id}")
+
+    request = Net::HTTP.const_get(HTTP_PUT).new(uri)
+    request.content_type = CONTENT_TYPE_JSON
+    request.body = attributes.to_json
+    add_auth_header(request)
+
+    response = send_request(uri, request)
+
+    if response.code == HTTP_OK
+      JSON.parse(response.body)
+    else
+      handle_error_response(response)
+    end
+  end
+
+  def delete_ticket(id)
+    uri = URI("#{@base_url}/api/defect_tickets/#{id}")
+
+    request = Net::HTTP::Delete.new(uri)
+    add_auth_header(request)
+
+    response = send_request(uri, request)
+
+    response.code == HTTP_NO_CONTENT
+  end
+
+  def export_tickets(format = DEFAULT_FORMAT, params = {})
+    query_params = params.map { |k, v| "#{k}=#{v}" }.join("&")
+    query_params += "&format=#{format}"
+
+    uri = URI("#{@base_url}#{API_EXPORT_PATH}")
+    uri.query = query_params
+
+    request = Net::HTTP::Get.new(uri)
+    add_auth_header(request)
+
+    response = send_request(uri, request)
+
+    if response.code == HTTP_OK
+      if format == "json"
+        JSON.parse(response.body)
+      else
+        response.body
+      end
+    else
+      handle_error_response(response)
+    end
+  end
+
+  private
+
+  def add_auth_header(request)
+    request["Authorization"] = "Bearer #{@auth_token}" if @auth_token
+  end
+
+  def send_request(uri, request)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.read_timeout = DEFAULT_TIMEOUT
+    http.open_timeout = DEFAULT_TIMEOUT
+    http.use_ssl = (uri.scheme == "https")
+
+    http.request(request)
+  end
+
+  def handle_error_response(response)
+    error_data = JSON.parse(response.body)
+    raise "API Error (#{response.code}): #{error_data["error"]}"
+  rescue JSON::ParserError
+    raise "API Error (#{response.code}): #{response.body}"
+  end
+end

data/lib/ticket/replicator/setup.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ticket
+  class Replicator
+    class Setup
+      SetupError = Class.new(StandardError)
+
+      attr_reader :replicator
+
+      def initialize(replicator)
+        @replicator = replicator
+      end
+
+      def run
+        create_queue
+        create_initial_configuration
+      end
+
+      private
+
+      def create_queue
+        log.info "Created folder #{replicator.extracted_folder.inspect}"
+      end
+
+      def create_initial_configuration
+        if File.exist?(config_file_path)
+          raise SetupError, "Not overwriting existing config file #{config_file_path.inspect}"
+        end
+
+        FileUtils.cp(example_config_file_path, config_file_path)
+
+        log.info { "Created file #{config_file_path.inspect}" }
+      end
+
+      def config_file_path
+        @config_file_path ||=
+          begin
+            path = RowTransformer.mapping_file_path
+            FileUtils.mkdir_p(File.dirname(path))
+            path
+          end
+      end
+
+      def example_config_file_path
+        File.join(replicator.home_dir, "config", "examples", File.basename(config_file_path))
+      end
+    end
+  end
+end

data/lib/ticket/replicator/ticket.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "ticket_status_transitioner"
+
+module Ticket
+  class Replicator
+    class Ticket
+      attr_reader :jira_auto_tool, :jira_ticket
+
+      def initialize(jira_auto_tool, jira_ticket)
+        @jira_auto_tool = jira_auto_tool
+        @jira_ticket = jira_ticket
+      end
+
+      def delete
+        jira_ticket.delete
+      end
+
+      def jira_client
+        jira_auto_tool.jira_client
+      end
+
+      def transition_to(status)
+        TicketStatusTransitioner.new(self).transition_to(status)
+      end
+
+      def <=>(other)
+        cmp_values(self) <=> cmp_values(other)
+      end
+
+      def replicated?
+        ReplicatedSummary.match?(summary)
+      end
+
+      def source_id
+        ReplicatedSummary.parse(summary).source_id
+      end
+
+      private
+
+      def cmp_values(object)
+        object&.source_id
+      end
+
+      def method_missing(name, *args)
+        if jira_ticket.respond_to?(name)
+          value = jira_ticket.send(name)
+
+          sanitize(value)
+        else
+          super
+        end
+      end
+
+      def sanitize(value)
+        if value.respond_to?(:name)
+          value.name
+        elsif value.respond_to?(:value)
+          value.value
+        else
+          value.nil? ? "" : value.to_s
+        end
+      end
+
+      def respond_to_missing?(name, *args)
+        jira_ticket.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/ticket/replicator/ticket_status_transitioner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ticket
+  class Replicator
+    class TicketStatusTransitioner
+      attr_reader :ticket
+
+      def initialize(ticket)
+        @ticket = ticket
+      end
+
+      def tool
+        @tool ||= ticket.jira_auto_tool
+      end
+
+      def transition_to(status)
+        return if status == ticket.status
+
+        ticket.jira_client.post(ticket.jira_auto_tool.jira_url("/rest/api/2/issue/#{ticket.key}/transitions"),
+                                transition_payload_for(status),
+                                http_headers)
+      end
+
+      def transition_payload_for(status)
+        transition = available_transitions.find { |transition| transition.fetch("to").fetch("name") == status } or
+          raise "No transition found for #{status.inspect} in " \
+                "#{available_transitions.collect { |t| "#{t["name"]} -> #{t["to"]["name"]}" }.inspect}."
+
+        { transition: { id: transition["id"] } }.to_json
+      end
+
+      def available_transitions
+        response = tool.jira_client.get(tool.jira_url("/rest/api/2/issue/#{ticket.key}?expand=transitions"))
+
+        JSON.parse(response.body).fetch("transitions")
+      end
+
+      def http_headers
+        {
+          "Content-Type" => "application/json"
+        }
+      end
+    end
+  end
+end

data/lib/ticket/replicator/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ticket
+  class Replicator
+    VERSION = "0.1.1"
+  end
+end

data/lib/ticket/replicator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "jira/auto/tool"
+
+require_relative "replicator/file_replicator"
+require_relative "replicator/file_loader"
+require_relative "replicator/file_transformer"
+require_relative "replicator/jira_project"
+require_relative "replicator/setup"
+require_relative "replicator/version"
+
+module Ticket
+  class Replicator
+    class Error < StandardError; end
+
+    def ticket_queue_transform_and_load
+      extracted_files.each { |file| FileReplicator.run_on(self, file) }
+    end
+
+    def jira_client
+      jira_auto_tool.jira_client
+    end
+
+    def jira_auto_tool
+      @jira_auto_tool ||= Jira::Auto::Tool.new
+    end
+
+    def jira_project
+      @jira_project = JiraProject.new(jira_auto_tool)
+    end
+
+    def transformed_queue_clear
+      FileUtils.rm_rf(transformed_folder)
+    end
+
+    def load
+      transformed_files.each { |file| FileReplicator.load(self, file) }
+    end
+
+    def transform
+      extracted_files.each { |file| FileReplicator.transform(self, file) }
+    end
+
+    def extracted_files
+      queue_files(extracted_folder)
+    end
+
+    def extracted_folder
+      queue_folder("10.extracted")
+    end
+
+    def transformed_files
+      queue_files(transformed_folder)
+    end
+
+    def transformed_folder
+      queue_folder("20.transformed")
+    end
+
+    def archived_folder
+      queue_folder("30.archived")
+    end
+
+    def queue_folder(*path_components)
+      path = File.join(queue_dir, *path_components)
+
+      FileUtils.mkdir_p(path)
+
+      path
+    end
+
+    def setup
+      Setup.new(self)
+    end
+
+    def home_dir
+      File.expand_path(File.join("..", ".."), __dir__)
+    end
+
+    private
+
+    def queue_dir
+      "queue"
+    end
+
+    def queue_files(queue_folder)
+      Dir.glob(File.join(queue_folder, "**", "*"))
+    end
+  end
+end

data/sig/ticket/replicator.rbs

@@ -0,0 +1,6 @@
+module Ticket
+  module Replicator
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "ticket/replicator"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end