ticket-replicator 0.1.1

data/features/transform_and_load_extracted_ticket_queue.feature

@@ -0,0 +1,121 @@
+Feature: Transform and load extracted ticket queue
+  In order to track the pending work in a unified view
+  As a stakeholder
+  I need the ability to transform and load extracted tickets to a Jira project
+
+  Background:
+    Given the following environment variables have already been set with a value:
+      | name                                    |
+      | TICKET_REPLICATOR_JIRA_PROJECT_KEY      |
+      | TICKET_REPLICATOR_JIRA_TICKET_TYPE_NAME |
+    And a file named "config/ticket-replicator.mappings.yml" with:
+      """
+      field_mapping:
+        id: Defect
+        summary: Defect (2)
+        priority: Defect Priority
+        resolution: Defect Status
+        status: Defect Status
+        team: Defect Support Team (2)
+
+      priority_mapping:
+        "1: Critical": "Highest"
+        "2: High": "High"
+        "3: Medium": "Medium"
+        "4: Low": "Low"
+
+      status_mapping:
+        defaults_to: keep_original_value
+
+      resolution_mapping:
+        defaults_to: keep_original_value
+        "New":
+        "Open":
+        "In Process":
+        "In Review":
+        "On Hold":
+        Deferred:
+        Defect Correction in Process:
+        "Fixed": "Fixed"
+        "Closed": "Done"
+        "Rejected": "Won't Do"
+        "Resolved": "Fixed"
+        "Confirmed":
+        "Forwarded":
+        "Information Required":
+        Wait for Defect Correction:
+        Solution Proposal:
+        Tester Action:
+        Wait on External:
+
+      team_mapping:
+        defaults_to: keep_original_value
+        "Frontend": "Web Team"
+        "Backend": "Server Team"
+        "Integration": "Integration Team"
+        "Mobile": "Mobile Team"
+        "Security": "Security Team"
+        "DevOps": "DevOps Team"
+        "QA": "Quality Assurance"
+        "Architecture": "Architecture Team"
+        "UX": "Design Team"
+        "Performance": "Performance Team"
+      """
+    And the project has no tickets
+
+  Scenario: Process Ticket Queue successfully
+    Given an Excel file named "queue/10.extracted/sap_solution_manager_defects.xlsx"
+    And it has a tab named "SAP Document Export" with the following rows:
+      | Defect     | Defect (2) | Defect Priority | Defect Status                | Defect Support Team (2) |
+      | 3000017049 | Summary    | 3: Medium       | Closed                       | A Team                  |
+      | 9400011377 | Summary    | 4: Low          | Confirmed                    | A Team                  |
+      | 3000016618 | Summary    | 3: Medium       | Defect Correction in Process | A Team                  |
+      | 9400013805 | Summary    | 3: Medium       | Deferred                     | A Team                  |
+      | 9400013816 | Summary    | 2: High         | Forwarded                    | A Team                  |
+      | 9400011382 | Summary    | 3: Medium       | In Process                   | A Team                  |
+      | 9400011393 | Summary    | 3: Medium       | Information Required         | A Team                  |
+      | 9400011381 | Summary    | 3: Medium       | New                          | A Team                  |
+      | 3000016617 | Summary    | 3: Medium       | No Error                     | A Team                  |
+      | 9400011372 | Summary    | 1: Critical     | Open                         | A Team                  |
+      | 9400011466 | Summary    | 3: Medium       | Withdrawn                    | A Team                  |
+      | 3000017667 | Summary    | 3: Medium       | Closed                       | Another Team            |
+      | 3000018423 | Summary    | 3: Medium       | No Error                     | A Team                  |
+    Then a file named "queue/10.extracted/sap_solution_manager_defects.xlsx" should exist
+    And the current date time is "2025-05-10 07:52:00 UTC"
+    When I successfully run `ticket-replicator --ticket-queue-transform-and-load`
+    Then the Jira project should only have the following tickets:
+      | status                       | resolution | priority | team         | summary                    | source ticket url                     |
+      | Closed                       | Done       | Medium   | A Team       | SMAN-3000017049 \| Summary | https://example.com/defect/3000017049 |
+      | Confirmed                    |            | Low      | A Team       | SMAN-9400011377 \| Summary | https://example.com/defect/9400011377 |
+      | Defect Correction in Process |            | Medium   | A Team       | SMAN-3000016618 \| Summary | https://example.com/defect/3000016618 |
+      | Deferred                     |            | Medium   | A Team       | SMAN-9400013805 \| Summary | https://example.com/defect/9400013805 |
+      | Forwarded                    |            | High     | A Team       | SMAN-9400013816 \| Summary | https://example.com/defect/9400013816 |
+      | In Process                   |            | Medium   | A Team       | SMAN-9400011382 \| Summary | https://example.com/defect/9400011382 |
+      | Information Required         |            | Medium   | A Team       | SMAN-9400011393 \| Summary | https://example.com/defect/9400011393 |
+      | New                          |            | Medium   | A Team       | SMAN-9400011381 \| Summary | https://example.com/defect/9400011381 |
+      | No Error                     |            | Medium   | A Team       | SMAN-3000016617 \| Summary | https://example.com/defect/3000016617 |
+      | Open                         |            | Highest  | A Team       | SMAN-9400011372 \| Summary | https://example.com/defect/9400011372 |
+      | Withdrawn                    | Won't Do   | Medium   | A Team       | SMAN-9400011466 \| Summary | https://example.com/defect/9400011466 |
+      | Closed                       | Done       | Medium   | Another Team | SMAN-3000017667 \| Summary | https://example.com/defect/3000017667 |
+      | No Error                     |            | Medium   | A Team       | SMAN-3000018423 \| Summary | https://example.com/defect/3000018423 |
+    # TODO: And the source ticket URL is found in the ticket descriptions of those tickets
+    And a file named "queue/30.archived/2025-05-10.07h52m00.sap_solution_manager_defects.xlsx" should exist
+    And the file named "queue/10.extracted/sap_solution_manager_defects.xlsx" should not exist anymore
+    And a file named "queue/20.transformed/sap_solution_manager_defects.csv" should not exist anymore
+
+  Scenario: Extracted files remain available for reprocessing in case of failure
+    Given an Excel file named "queue/10.extracted/sap_solution_manager_defects.xlsx"
+    And it has a tab named "SAP Document Export" with the following rows:
+      | Defect     | Defect (2) | Defect Priority | Defect Status                     | Defect Support Team (2) |
+      | 3000017049 | Summary    | 3: Medium       | __UNKNOWN STATUS Causing Error___ | A Team                  |
+      | 3000017667 | Summary    | 3: Medium       | Closed                            | Another Team            |
+      | 3000018423 | Summary    | 3: Medium       | No Error                          | A Team                  |
+    Then a file named "queue/10.extracted/sap_solution_manager_defects.xlsx" should exist
+    When I run `ticket-replicator --tqtal`
+    Then it should fail with:
+      """
+      ERROR  Object : Ticket::Replicator::FileLoader::LoadError: queue/20.transformed/sap_solution_manager_defects.csv:2: error while loading row:
+      No transition found for "__UNKNOWN STATUS Causing Error___" in
+      """
+    And the file named "queue/10.extracted/sap_solution_manager_defects.xlsx" should exist
+    And a file named "queue/20.transformed/sap_solution_manager_defects.csv" should exist

data/lib/tasks/version.rake

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+def validate_version_type(type)
+  valid_types = %w[patch minor major]
+  return if valid_types.include?(type)
+
+  puts "Error: Version type must be one of: #{valid_types.join(", ")}"
+  exit 1
+end
+
+def execute_version_bump(type)
+  puts "Bumping #{type} version..."
+  bump_result = system("bundle exec gem bump --version #{type}")
+  return if bump_result
+
+  puts "Error: Failed to bump version"
+  exit 1
+end
+
+def update_gemfile_lock
+  puts "Updating Gemfile.lock..."
+  bundle_result = system("bundle install")
+  return if bundle_result
+
+  puts "Error: Failed to update Gemfile.lock"
+  exit 1
+end
+
+def amend_commit_to_include_gemfile_lock_changes
+  puts "Amending commit to include Gemfile.lock update..."
+  system("git add .")
+  system("git commit --amend --no-edit")
+end
+
+namespace :version do
+  desc "Bump version (patch, minor, major) and update Gemfile.lock in a single step. Default: patch"
+  task :bump, [:type] do |_t, args|
+    args.with_defaults(type: "patch")
+
+    validate_version_type(args.type)
+
+    execute_version_bump(args.type)
+    update_gemfile_lock
+    amend_commit_to_include_gemfile_lock_changes
+
+    puts <<~EOEM
+      Version successfully bumped and committed!
+
+      Run 'git push' to push the changes to your remote repository.
+    EOEM
+  end
+end
+
+desc "Alias for version:bump"
+task :bump, [:type] => ["version:bump"]

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "mock_sap_client"
+require "logger"
+require "fileutils"
+
+class DefectExportAutomation
+  def initialize
+    @client = SAPSolutionManagerClient.new("http://localhost:4567")
+    @logger = Logger.new($stdout)
+    @logger.level = Logger::INFO
+
+    # Create exports directory if it doesn't exist
+    FileUtils.mkdir_p("exports")
+  end
+
+  def run_all_scenarios
+    # Authenticate
+    authenticate
+
+    # Run scenarios
+    export_all_defects
+    export_filtered_defects
+
+    @logger.info { "All export scenarios completed successfully!" }
+  rescue StandardError => e
+    @logger.error("Automation failed: #{e.message}")
+    @logger.error(e.backtrace.join("\n"))
+  end
+
+  private
+
+  def authenticate
+    @logger.info { "Authenticating with SAP Solution Manager..." }
+    raise "Authentication failed" unless @client.authenticate("test_user", "test_password")
+
+    @logger.info { "Authentication successful" }
+  end
+
+  def export_all_defects
+    @logger.info { "Scenario 1: Exporting all defect tickets..." }
+    export_all_defects_json
+    export_all_defects_csv
+  end
+
+  def export_all_defects_json
+    @logger.info { "Exporting all tickets as JSON..." }
+    result_json = @client.export_tickets("json")
+    File.write("exports/all_defects.json", result_json.to_json)
+    @logger.info { "Exported #{result_json['tickets'].size} tickets to exports/all_defects.json" }
+  end
+
+  def export_all_defects_csv
+    @logger.info { "Exporting all tickets as CSV..." }
+    result_csv = @client.export_tickets("csv")
+    File.write("exports/all_defects.csv", result_csv)
+    lines_count = result_csv.split("\n").size - 1
+    @logger.info { "Exported #{lines_count} tickets to exports/all_defects.csv" }
+  end
+
+  def export_filtered_defects
+    @logger.info { "Scenario 2: Exporting filtered defect tickets..." }
+    create_test_tickets
+
+    export_status_filtered
+    export_priority_filtered
+    export_complex_filtered
+    export_csv_filtered
+  end
+
+  def export_status_filtered
+    @logger.info { "Exporting tickets with status 'IN_PROGRESS'..." }
+    status_result = @client.export_tickets("json", { status: "IN_PROGRESS" })
+    File.write("exports/in_progress_defects.json", status_result.to_json)
+    @logger.info { "Exported #{status_result['tickets'].size} tickets with IN_PROGRESS status" }
+  end
+
+  def export_priority_filtered
+    @logger.info { "Exporting tickets with HIGH priority..." }
+    priority_result = @client.export_tickets("json", { priority: "HIGH" })
+    File.write("exports/high_priority_defects.json", priority_result.to_json)
+    @logger.info { "Exported #{priority_result['tickets'].size} tickets with HIGH priority" }
+  end
+
+  def export_complex_filtered
+    @logger.info { "Exporting tickets with multiple filters..." }
+    complex_result = @client.export_tickets("json", {
+                                              status: "NEW",
+                                              priority: "CRITICAL",
+                                              assigned_to: "URGENT_TEAM"
+                                            })
+    File.write("exports/critical_new_defects.json", complex_result.to_json)
+    @logger.info { "Exported #{complex_result['tickets'].size} tickets matching complex criteria" }
+  end
+
+  def export_csv_filtered
+    @logger.info { "Exporting filtered tickets as CSV..." }
+    csv_result = @client.export_tickets("csv", { priority: "HIGH" })
+    File.write("exports/high_priority_defects.csv", csv_result)
+    lines_count = csv_result.split("\n").size - 1
+    @logger.info { "Exported #{lines_count} tickets to exports/high_priority_defects.csv" }
+  end
+
+  def create_test_tickets
+    @logger.info { "Creating test tickets for filtering scenarios..." }
+
+    # Create a few tickets with different attributes for testing filters
+    statuses = %w[NEW IN_PROGRESS RESOLVED CLOSED]
+    priorities = %w[LOW MEDIUM HIGH CRITICAL]
+
+    10.times do |i|
+      status = statuses[i % statuses.length]
+      priority = priorities[i % priorities.length]
+
+      ticket = @client.create_ticket({
+                                       description: "Test ticket #{i + 1} for filtering",
+                                       status: status,
+                                       priority: priority,
+                                       assigned_to: priority == "CRITICAL" ? "URGENT_TEAM" : "USER_#{i + 1}"
+                                     })
+
+      @logger.info { "Created ticket #{ticket['ticket_id']} with status #{status}, priority #{priority}" }
+    end
+  end
+end
+
+# Run the automation if this file is executed directly
+DefectExportAutomation.new.run_all_scenarios if __FILE__ == $PROGRAM_NAME

data/lib/ticket/replicator/file_loader.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "ticket/replicator/row_loader"
+
+module Ticket
+  class Replicator
+    class FileLoader
+      class LoadError < StandardError; end
+
+      def self.run_on(jira_project, file_path)
+        log.info { "Loading #{file_path} into #{jira_project.project_key}..." }
+
+        new(jira_project, file_path).run
+      end
+
+      private_class_method :new
+
+      attr_reader :jira_project, :extracted_path
+
+      def initialize(jira_project, extracted_path)
+        @jira_project = jira_project
+        @extracted_path = extracted_path
+      end
+
+      FIRST_DATA_ROW_LINE_NUMBER = 2
+      def run
+        rows.each_with_index do |row, index|
+          line_number = index + FIRST_DATA_ROW_LINE_NUMBER
+          RowLoader.run_on(jira_project, row)
+        rescue StandardError => e
+          message = <<~EOERROR
+            #{extracted_path}:#{line_number}: error while loading row:
+            #{e.message}:
+            #{row.inspect}
+          EOERROR
+
+          raise LoadError, message
+        end
+      end
+
+      def rows
+        CSV.read(extracted_path, headers: true, header_converters: :symbol)
+      end
+    end
+  end
+end

data/lib/ticket/replicator/file_replicator.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "ticket/replicator"
+
+module Ticket
+  class Replicator
+    class FileReplicator
+      def self.run_on(replicator, extracted_path)
+        new(replicator, extracted_path).run
+      end
+
+      def self.load(replicator, transformed_path)
+        FileLoader.run_on(replicator.jira_project, transformed_path)
+      end
+
+      def self.transform(replicator, extracted_path)
+        new(replicator, extracted_path).transform
+      end
+
+      private_class_method :new
+
+      attr_reader :replicator, :extracted_path
+
+      def initialize(replicator, extracted_path)
+        @replicator = replicator
+        @extracted_path = extracted_path
+      end
+
+      def run
+        transform
+        load
+        delete_transformed_file
+        archive_extracted_file
+      end
+
+      def load
+        self.class.load(replicator, transformed_path)
+      end
+
+      def transform
+        FileTransformer.run_on(extracted_path, transformed_path)
+      end
+
+      def delete_transformed_file
+        FileUtils.rm(transformed_path)
+      end
+
+      def archive_extracted_file
+        FileUtils.mv(extracted_path, archived_path)
+      end
+
+      def transformed_path
+        @transformed_path ||=
+          extracted_path.sub(/#{Regexp.escape(replicator.extracted_folder)}/, replicator.transformed_folder)
+                        .sub(/\.xlsx$/, ".csv")
+      end
+
+      def archived_path
+        File.join(replicator.archived_folder, "#{timestamp}.#{File.basename(extracted_path)}")
+      end
+
+      def timestamp
+        Jira::Auto::Tool::Helpers::OverridableTime.now.strftime("%Y-%m-%d.%Hh%Mm%S")
+      end
+    end
+  end
+end

data/lib/ticket/replicator/file_transformer/for_csv.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ticket
+  class Replicator
+    class FileTransformer
+      class ForCSV < FileTransformer
+        CSVReaderError = Class.new(StandardError)
+
+        CSV_FIRST_LINE_NUMBER = 1
+
+        def extracted_rows
+          CSV.read(extracted_path, headers: true, header_converters: :downcase)
+        rescue StandardError => e
+          raise CSVReaderError, <<~EOERRORMSG
+            #{extracted_path}:#{CSV_FIRST_LINE_NUMBER}: error while reading CSV file:
+            #{e.message}
+          EOERRORMSG
+        end
+      end
+    end
+  end
+end

data/lib/ticket/replicator/file_transformer/for_xlsx.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "creek"
+
+module Ticket
+  class Replicator
+    class FileTransformer
+      class ForXLSX < FileTransformer
+        class XLSXReaderError < StandardError; end
+
+        XLS_FIRST_LINE_NUMBER = 1
+
+        def extracted_rows
+          rows = sheet.simple_rows.to_a
+
+          headers = rows.shift.values.collect(&:downcase)
+
+          rows.collect { |row| headers.zip(row.values).to_h }
+        rescue StandardError => e
+          raise XLSXReaderError, <<~EOERRORMSG
+            #{extracted_path}:#{XLS_FIRST_LINE_NUMBER}: error while reading XLSX file:
+            #{e.message}
+          EOERRORMSG
+        end
+
+        private
+
+        def sheet
+          Creek::Book.new(extracted_path, convert_numerics: false).sheets.first
+        end
+      end
+    end
+  end
+end

data/lib/ticket/replicator/file_transformer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "row_transformer"
+require "csv"
+require "fileutils"
+require "ticket/replicator"
+require_relative "file_transformer/for_csv"
+require_relative "file_transformer/for_xlsx"
+
+module Ticket
+  class Replicator
+    class FileTransformer
+      class TransformError < StandardError; end
+
+      def self.run_on(extracted_path, transformed_path)
+        run_class(extracted_path).send(:new, extracted_path, transformed_path).run
+      end
+
+      def self.run_class(extracted_path)
+        "#{name}::For#{file_extension_without_dot(extracted_path).upcase}".constantize
+      end
+
+      def self.file_extension_without_dot(extracted_path)
+        File.extname(extracted_path).gsub(".", "")
+      end
+
+      private_class_method :new
+
+      attr_reader :extracted_path, :transformed_path
+
+      def initialize(extracted_path, transformed_path)
+        @extracted_path = extracted_path
+        @transformed_path = transformed_path
+      end
+
+      def run
+        CSV.open(transformed_path, "wb", force_quotes: true) do |csv|
+          csv << transformed_headers
+          transformed_rows.each { |row| csv << row }
+        end
+      end
+
+      def extracted_rows
+        raise NotImplementedError, "You must implement this method in your subclass"
+      end
+
+      FIRST_EXTRACTED_DATA_ROW_LINE_NUMBER = 2
+      private_constant :FIRST_EXTRACTED_DATA_ROW_LINE_NUMBER
+
+      def transformed_rows
+        row_index = FIRST_EXTRACTED_DATA_ROW_LINE_NUMBER
+        extracted_rows.collect do |row|
+          RowTransformer.run_on(row)
+        rescue StandardError => e
+          raise TransformError, <<~EOERRORMSG
+            #{extracted_path}:#{row_index}: error while transforming row:
+            #{e.message}:
+            #{row.inspect}
+          EOERRORMSG
+        ensure
+          row_index += 1
+        end
+      end
+
+      def transformed_headers
+        RowTransformer.fields_to_transform.collect(&:to_s)
+      end
+    end
+  end
+end

data/lib/ticket/replicator/jira_project.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "jira/resource/issue"
+require "jira/auto/tool/helpers/pagination"
+require "ticket/replicator/row_transformer"
+require "ticket/replicator/ticket"
+
+module Ticket
+  class Replicator
+    class JiraProject
+      attr_reader :jira_auto_tool
+
+      def initialize(jira_auto_tool)
+        @jira_auto_tool = jira_auto_tool
+      end
+
+      def jira_client
+        jira_auto_tool.jira_client
+      end
+
+      def delete_all_tickets_from_the_expected_type
+        replicated_tickets.each(&:delete)
+      end
+
+      def project_key
+        @project_key ||= ENV.fetch("TICKET_REPLICATOR_JIRA_PROJECT_KEY")
+      end
+
+      def ticket_type_name
+        @ticket_type_name ||= ENV.fetch("TICKET_REPLICATOR_JIRA_TICKET_TYPE_NAME")
+      end
+
+      def replicated_tickets
+        @replicated_tickets ||= all_replicated_ticket_pages.to_h { |ticket| [ticket.source_id, ticket] }
+      end
+
+      def all_tickets(all_ticket_jql = "project = #{project_key}")
+        all_jira_tickets(all_ticket_jql).collect { |ticket| Replicator::Ticket.new(jira_auto_tool, ticket) }
+      end
+
+      private
+
+      def all_jira_tickets(all_ticket_jql)
+        Jira::Auto::Tool::Helpers::Pagination.fetch_all_object_pages(:snake_case) do |pagination_options|
+          jira_client.Issue.jql(all_ticket_jql, pagination_options)
+        end
+      end
+
+      def all_replicated_ticket_pages
+        all_tickets(replicated_ticket_jql).find_all(&:replicated?).sort_by(&:source_id)
+      end
+
+      def replicated_ticket_jql
+        <<-EOJQL
+            project = #{project_key}
+        AND issuetype = #{ticket_type_name.inspect}
+        EOJQL
+      end
+
+      def jira_client_project
+        @jira_client_project ||= jira_client.Project.find(project_key)
+      end
+    end
+  end
+end

data/lib/ticket/replicator/replicated_summary.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "English"
+require "ticket/replicator"
+
+module Ticket
+  class Replicator
+    class ReplicatedSummary
+      class ParseError < StandardError; end
+
+      TICKET_ID_PREFIX = "SMAN-"
+      TICKET_ID_PREFIX_SEPARATOR = " | "
+      TICKET_ID_PREFIX_REGEX =
+        /^#{Regexp.escape(TICKET_ID_PREFIX)}(?<source_id>.+?)#{Regexp.escape(TICKET_ID_PREFIX_SEPARATOR)}
+          (?<source_summary>.+)$/x
+
+      def self.build(source_id, source_summary)
+        new(source_id, source_summary)
+      end
+
+      def self.match?(replicated_summary_string)
+        TICKET_ID_PREFIX_REGEX.match(replicated_summary_string)
+      end
+
+      def self.parse(replicated_summary_string)
+        match_result = match?(replicated_summary_string)
+
+        unless match_result
+          raise ParseError,
+                "#{replicated_summary_string.inspect}: missing expected prefix format: " \
+                "not matching #{TICKET_ID_PREFIX_REGEX.inspect}."
+        end
+
+        new(match_result[:source_id], match_result[:source_summary])
+      end
+
+      MATCH_ANY_CHARACTER_IN_JQL = "%"
+
+      def self.jql_pattern
+        [
+          TICKET_ID_PREFIX,
+          TICKET_ID_PREFIX_SEPARATOR
+        ].join(MATCH_ANY_CHARACTER_IN_JQL)
+      end
+
+      private_class_method :new
+
+      attr_reader :source_summary, :source_id
+
+      def initialize(source_id, source_summary)
+        @source_id = source_id
+        @source_summary = source_summary
+      end
+
+      def to_s
+        [
+          transformed_summary_prefix,
+          source_summary
+        ].join
+      end
+
+      private
+
+      def transformed_summary_prefix
+        [
+          TICKET_ID_PREFIX,
+          source_id,
+          TICKET_ID_PREFIX_SEPARATOR
+        ].join
+      end
+    end
+  end
+end