apadmi_grout 1.1.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f779ff10f50f15d2ce74311339c8407ae32eec3bcc8fb49f0ab3a85d8a0cbdc7
-  data.tar.gz: e0f9034584fdcafb95355ade65f64ccdd7e82acc2e07d62a5bd61129e3fc5464
+  metadata.gz: f1a387b90108f0657af3875457b1eb98440b54d7fdf6d62a9750fe1af10aeca5
+  data.tar.gz: 25fe6b6ca1083a991f088d2161f49997f04944dda1225617192c9fcf2494f511
 SHA512:
-  metadata.gz: 10b206d1d56814b6288bf0db35259c02c81baf0c3554de6286627498c0d65ee6f8808fafcd5908038be9a196ae264952180fc4988ca15b4023dd03a1380c98be
-  data.tar.gz: ecbf93eb1f3bd3141a54949568edc1196ad6b7aaf7348f89f93e9fb46bf76aa424504cf2a5bc5d9effd78f811543322980c65a7e83231cdb283ca492aec53fc8
+  metadata.gz: ca2dee35cca80456ca3ebd01b8ab1e1c89eb6c9bad069b36a1e20f8ae36bb511144fed3de12d8dccc31cc8c9dd364684bbdcee4af69244ff180d6e8af4ac24d2
+  data.tar.gz: 49414ee4d8507110fed1bbf50946c16357039aacbc1e6657f32c1c4b4777d0ea013559da5c99fc65c77ea5a55d5d4e61479ed7b433dac81885d532dcab4eeaaa

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Core Changelog
 
+## [2.1.0] - 22-07-26
+* Added a few bitrise utils to support listing builds, triggering builds and downloading artifacts.
+* Added utilities to the network service to upload files
+
+## [2.0.0] - 2022-05-25
+* Almost total refactor to support having different board providers (other than jira)
+* Implement ADO support for all existing actions
+
+## [1.2.0] - 2022-05-17
+* Filter out issues missing from git changelogs when finding tickets to move.
+
 ## [1.1.0] - 2022-05-12
 * Support allowing tickets that aren't assigned to a sprint to be moved.
 * Created utilities for getting the git root and number of commits

data/lib/apadmi/grout/actions/find_tickets_to_move_action/find_tickets_to_move_action.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # Generic action for finding tickets to move
+    class FindTicketsToMoveAction
+      # @param _component [String] Only include tickets tagged with this component
+      # @param _status [String] The status of tickets to be moved (Usually "Awaiting QA Release")
+      # @param _excluded_ticket_keys [Array<String>] ticket keys to be excluded from consideration
+      # @param _custom_flag_messages [Apadmi::Grout::FlagMessages]
+      # @param _options [Apadmi::Grout::JiraFindTicketsOptions|Apadmi::Grout::AdoFindTicketsOptions]
+      # @return [Array<Apadmi::Grout::Issue>] the issues ready to move
+      def run(
+        _component,
+        _status,
+        _excluded_ticket_keys,
+        _custom_flag_messages = nil,
+        _options = nil
+      )
+        raise "Unimplemented :("
+      end
+    end
+  end
+end

data/lib/apadmi/grout/actions/find_tickets_to_move_action/find_tickets_to_move_ado_action.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # ATTENTION: Any changes to the logic here should be reflected in the docs (find-tickets.md)
+
+    # Finds and returns a list of all the issues that are ready to be moved
+    # Any tickets found that have the given status but *don't* appear ready to be moved will
+    # be flagged.
+    class FindTicketsToMoveAdoAction < FindTicketsToMoveAction
+      # @param [Apadmi::Grout::AdoBoardService]
+      # @param [String]
+      # @param [Apadmi::Grout::GitUtils]
+      # @param [Apadmi::Grout::IssuesFromChangelogAction]
+      # @param [Apadmi::Grout::DefaultLogger] // or your own logger!
+      def initialize(ado_board_service, ticket_prefix, git_utils, issues_from_chnglg, logger)
+        @ado_board_service = ado_board_service
+        @ticket_prefix = ticket_prefix
+        @git_utils = git_utils
+        @issues_from_changelog_action = issues_from_chnglg
+        @logger = logger
+      end
+
+      # @param component [String] Only include tickets tagged with this component
+      # @param status [String] The status of tickets to be moved (Usually "Awaiting QA Release")
+      # @param excluded_ticket_keys [Array<String>] ticket keys to be excluded from consideration
+      # @param custom_flag_messages [Apadmi::Grout::FlagMessages]
+      # @param options [Apadmi::Grout::JiraFindTicketsOptions]
+      # @return [Array<Apadmi::Grout::Issue>] the issues ready to move
+      def run(
+        component,
+        status,
+        excluded_ticket_keys,
+        custom_flag_messages = nil,
+        options = nil
+      )
+        custom_flag_messages ||= Apadmi::Grout::FlagMessages.default(status)
+        options ||= Apadmi::Grout::AdoFindTicketsOptions.new(required_tags: [],
+                                                             not_tags: [])
+
+        issues = @ado_board_service.search_unblocked_issues(
+          component, status, [], options
+        ).reject { |issue| excluded_ticket_keys.include? issue.key }
+
+        issue_keys = issues.map(&:key)
+        @logger.message("Found issues to consider #{issue_keys.join(", ")}")
+
+        # Get the issues in the git changelog, filtered for the issues being considered
+        changelog_ids = @issues_from_changelog_action.issue_ids_from_changelog(
+          @git_utils.merge_changelog(issue_keys)
+        ).map { |id| id.delete_prefix(@ticket_prefix) }
+
+        @git_utils.fetch_all
+        # issues that have been merged, but aren't in this build.
+        # This is a valid state (e.g. merged into a release branch but not develop)
+        invert_changelog_ids = @issues_from_changelog_action.issue_ids_from_changelog(
+          @git_utils.invert_changelog(issue_keys)
+        ).map { |id| id.delete_prefix(@ticket_prefix) }
+
+        final_list = issues.filter do |issue|
+          # Flag the ticket if it doesn't include in either changelog since
+          # this means the ticket is likely in an incorrect state
+          decide_should_include(changelog_ids, custom_flag_messages, invert_changelog_ids, issue)
+        end
+
+        @logger.message("Final list: #{final_list.map(&:key).join(", ")}")
+        final_list
+      end
+
+      private
+
+      def decide_should_include(changelog_ids, custom_flag_messages, invert_changelog_ids, issue)
+        if !changelog_ids.include?(issue.key) && !invert_changelog_ids.include?(issue.key)
+          @ado_board_service.flag_ticket(
+            issue.key,
+            custom_flag_messages.no_prs_flag_msg
+          )
+          @logger.message("Not including #{issue.key} since it's not in the changelog at all")
+          return false
+        end
+
+        if !changelog_ids.include?(issue.key) && invert_changelog_ids.include?(issue.key)
+          @logger.message("Not including #{issue.key} since it's merged but not in this build")
+          return false
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/apadmi/grout/actions/find_tickets_to_move_action/find_tickets_to_move_jira_action.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    module PrStatus
+      MERGED = 1
+      UNMERGED_BUT_INCLUDED = 2
+      UN_INCLUDED = 3
+    end
+
+    # ATTENTION: Any changes to the logic here should be reflected in the docs (find-tickets.md)
+
+    # Finds and returns a list of all the issues that are ready to be moved
+    # Any tickets found that have the given status but *don't* appear ready to be moved will
+    # be flagged.
+    class FindTicketsToMoveJiraAction < FindTicketsToMoveAction
+      # @param [Apadmi::Grout::JiraBoardService]
+      # @param [Apadmi::Grout::GitUtils]
+      # @param [Apadmi::Grout::IssuesFromChangelogAction]
+      # @param [Apadmi::Grout::DefaultLogger] // or your own logger!
+      def initialize(jira_board_service, git_utils, issues_from_chnglg, logger)
+        @jira_board_service = jira_board_service
+        @git_utils = git_utils
+        @issues_from_changelog_action = issues_from_chnglg
+        @logger = logger
+      end
+
+      # @param component [String] Only include tickets tagged with this component
+      # @param status [String] The status of tickets to be moved (Usually "Awaiting QA Release")
+      # @param excluded_ticket_keys [Array<String>] ticket keys to be excluded from consideration
+      # @param custom_flag_messages [Apadmi::Grout::FlagMessages]
+      # @param options [Apadmi::Grout::JiraFindTicketsOptions]
+      # @return [Array<Apadmi::Grout::Issue>] the issues ready to move
+      def run(
+        component,
+        status,
+        excluded_ticket_keys,
+        custom_flag_messages = nil,
+        options = nil
+      )
+        custom_flag_messages ||= Apadmi::Grout::FlagMessages.default(status)
+        options ||= Apadmi::Grout::JiraFindTicketsOptions.new(include_no_sprint_tickets: false)
+
+        issues = @jira_board_service.search_unblocked_issues(
+          component, status, [], options
+        ).reject do |issue|
+          excluded_ticket_keys.include? issue.key
+        end
+
+        issue_keys = issues.map(&:key)
+        @logger.message("Found issues to consider #{issue_keys.join(", ")}")
+
+        # Get the issues in the git changelog, filtered for the issues being considered
+        changelog_ids = @issues_from_changelog_action.issue_ids_from_changelog(
+          @git_utils.merge_changelog(issue_keys)
+        )
+
+        final_list = issues.filter do |issue|
+          # Decide whether to include this ticket based on PRs
+          status = process_prs(issue, custom_flag_messages)
+          decide_should_include(issue, status, changelog_ids)
+        end
+
+        @logger.message("Final list:  #{final_list.map(&:key).join(", ")}")
+        final_list
+      end
+
+      private
+
+      # @param issue [Apadmi::Grout::Issue]
+      # @param pr_status [Int] status of whether or not we can move
+      # @param changelog_ids [Array<String>] the ticket ids pulled from git
+      def decide_should_include(issue, pr_status, changelog_ids)
+        # For merged PRs, check if the ticket appears in the changelog.
+        # If it doesn't then it's likely it was merged AFTER this release build was triggered and shouldn't be moved
+        # by this build
+        if pr_status == PrStatus::MERGED
+          is_in_changelog = changelog_ids.include?(issue.key)
+          @logger.message("NOTE: Not including #{issue.key} since it's not in the git changelog.") unless is_in_changelog
+          return is_in_changelog
+        end
+
+        pr_status != PrStatus::UN_INCLUDED
+      end
+
+      # @param issue [Apadmi::Grout::Issue]
+      # @param custom_flag_messages [FlagMessages]
+      # @return [Int] status of whether or not we can move
+      def process_prs(issue, custom_flag_messages)
+        prs = @jira_board_service.get_ticket_prs(issue)
+
+        if prs.empty?
+          @logger.message("#{issue.key} has no PRs. Flagging it: STILL MOVABLE")
+          @jira_board_service.flag_ticket(issue.key, custom_flag_messages.no_prs_flag_msg)
+          return PrStatus::UNMERGED_BUT_INCLUDED
+        elsif prs.all?(&:open)
+          @logger.message("#{issue.key} has only open PRs. Flagging it: NOT MOVABLE")
+          @jira_board_service.flag_ticket(issue.key, custom_flag_messages.open_prs_flag_msg)
+          return PrStatus::UN_INCLUDED
+        elsif prs.all?(&:declined)
+          @logger.message("#{issue.key} has only declined PRs. Flagging it: NOT MOVABLE")
+          @jira_board_service.flag_ticket(issue.key, custom_flag_messages.declined_prs_flag_msg)
+          return PrStatus::UN_INCLUDED
+        elsif prs.none?(&:merged)
+          @logger.message("#{issue.key} has no merged PRs. Flagging it: NOT MOVABLE")
+          @jira_board_service.flag_ticket(issue.key, custom_flag_messages.no_merged_prs_flag_msg)
+          return PrStatus::UN_INCLUDED
+        end
+
+        PrStatus::MERGED # At least one merged PR
+      end
+    end
+  end
+end

data/lib/apadmi/grout/actions/generate_release_notes_action/generate_release_notes_action.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "mustache"
+
+module Apadmi
+  module Grout
+    # Finds and returns a list of all the issues who's ids exist in the given changelog
+    class GenerateReleaseNotesAction
+      # @param classifier [Apadmi::Grout::IssueClassifier]
+      def initialize(classifier)
+        @classifier = classifier
+      end
+
+      # @param config [Apadmi::Grout::ReleaseNotesConfig]
+      def run(config)
+        moved = @classifier.classify(config.moved_issues)
+        release = @classifier.classify(config.release_issues)
+
+        CustomMustache.render(
+          config.templates.document_template,
+          config: config,
+          rendered_moved_issues: render_classified_issues(config.templates.list_template, moved),
+          rendered_release_issues: render_classified_issues(config.templates.list_template, release)
+        ).strip
+      end
+
+      private
+
+      def render_classified_issues(template, classified_issues)
+        return if classified_issues.empty
+
+        CustomMustache.render(
+          template,
+          classified_issues: classified_issues
+        )
+      end
+    end
+
+    # Custom mustache class which doesn't escape HTML, since we're generating markdown
+    class CustomMustache < Mustache
+      # rubocop:disable Naming/MethodName
+      def escapeHTML(txt)
+        txt
+      end
+      # rubocop:enable Naming/MethodName
+    end
+  end
+end

data/lib/apadmi/grout/actions/generate_release_notes_action/issue_classifier.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # Generic issue classifier
+    class IssueClassifier
+      # @param types [Array<String>] List of types to match on
+      # @param issues [Array<Apadmi::Grout::Issue>]
+      # @return [Array<Apadmi::Grout::Issue>]
+      def filter_issues_by_type(types, issues)
+        issues.find_all { |issue| types.include?(issue.issue_type) }
+      end
+    end
+
+    # Jira specific issue classifier
+    class JiraIssueClassifier < IssueClassifier
+      # @param issues [Array<Apadmi::Grout::Issue>]
+      def classify(issues)
+        tasks = filter_issues_by_type(%w[Task], issues)
+        features = filter_issues_by_type(%w[Story], issues)
+        improvements = filter_issues_by_type(%w[Improvement Rework Debt], issues)
+        defects = filter_issues_by_type(%w[Bug], issues)
+        ClassifiedIssues.new(
+          tasks,
+          features,
+          improvements,
+          defects,
+          issues - tasks - features - improvements - defects
+        )
+      end
+    end
+
+    # Ado specific issue classifier
+    class AdoIssueClassifier < IssueClassifier
+      # @param issues [Array<Apadmi::Grout::Issue>]
+      def classify(issues)
+        tasks = filter_issues_by_type(%w[Task], issues)
+        features = filter_issues_by_type(["User Story", "Feature"], issues)
+        improvements = filter_issues_by_type(["Improvement", "Tech Debt"], issues)
+        defects = filter_issues_by_type(%w[Bug], issues)
+        ClassifiedIssues.new(
+          tasks,
+          features,
+          improvements,
+          defects,
+          issues - tasks - features - improvements - defects
+        )
+      end
+    end
+  end
+end

data/lib/apadmi/grout/{release_notes/actions → actions}/issues_from_changelog_action.rb

@@ -4,28 +4,31 @@ module Apadmi
   module Grout
     # Finds and returns a list of all the issues who's ids exist in the given changelog
     class IssuesFromChangelogAction
-      # @param [Apadmi::Grout::JiraWrapper]
+      # @param board_service [Apadmi::Grout::BoardService]
+      # @param ticket_prefix [String] The prefix for the ticket numbers in git e.g "PPT-"
       # @param [Apadmi::Grout::DefaultLogger] // or your own logger!
-      def initialize(jira_wrapper, logger)
-        @jira_wrapper = jira_wrapper
+      def initialize(board_service, ticket_prefix, logger)
+        @board_service = board_service
         @logger = logger
+        @ticket_prefix = ticket_prefix
       end
 
       # @param changelog [String] raw git changelog
-      # @return [Array<JIRA::Resource::Issue>] list of issues from changelog
+      # @return [Array<Apadmi::Grout::Issue>] list of issues from changelog
       def run(changelog)
         ids = issue_ids_from_changelog(changelog)
 
         @logger.message("Found issue ids: #{ids.join(", ")}")
-        @jira_wrapper.find_issues_by_keys(ids)
+        @board_service.find_issues_by_keys(ids)
       end
 
-      private
-
       # @param changelog [String] raw git changelog
       # @return [Array<String>] list of issue ids from changelog
       def issue_ids_from_changelog(changelog)
-        changelog.scan(/(#{@jira_wrapper.issue_id_prefix}-\d+)/).flatten.uniq
+        # Changelog often has the pull request number in it, this can mess up the parsing so strip it out if we can
+        changelog = changelog.gsub(/\(pull request.*\)/, "")
+
+        changelog.scan(/(#{@ticket_prefix}\d+)/).flatten.uniq
       end
     end
   end

data/lib/apadmi/grout/actions/move_tickets_action.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # Moves all given tickets to a given status and assigns fix versions
+    class MoveTicketsAction
+      # @param [Apadmi::Grout::BoardService]
+      # @param [Apadmi::Grout::DefaultLogger] // or your own logger!
+      def initialize(board_service, logger)
+        @board_service = board_service
+        @logger = logger
+      end
+
+      # @param [Array<String>] version_strings
+      # @param [Array<Apadmi::Grout::Issue>] issues
+      # @param [String] new_status
+      def run(version_strings, issues, new_status)
+        if issues.empty?
+          @logger.error("No issues found, aborting")
+          return
+        end
+
+        @logger.message("Transitioning issues: #{issues.map(&:key).join(", ")}")
+
+        issues.each do |issue|
+          @board_service.transition_issue(issue, new_status)
+          @board_service.assign_fixversions(issue.key, version_strings)
+        end
+
+        @logger.success("Issues transitioned successfully :D")
+      end
+    end
+  end
+end

data/lib/apadmi/grout/di.rb

@@ -3,22 +3,72 @@
 module Apadmi
   module Grout
     # Convenience class for initializing and accessing the various actions
-    class DependencyInjector
-      attr_reader :jira_wrapper, :move_jira_tickets_action, :find_tickets_to_move_action, :generate_release_notes_action, :issues_from_changelog_action
-
+    DependencyInjector = Struct.new(
+      :board_service,
+      :move_tickets_action,
+      :find_tickets_to_move_action,
+      :issues_from_changelog_action,
+      :generate_release_notes_action,
+      keyword_init: true
+    ) do
       # @param [String] username
       # @param [String] token
       # @param [String] base_url
       # @param [String] context_path
       # @param [String] project
       # @param [Logger] logger
-      def initialize(username, token, base_url, context_path, project, logger)
-        @jira_wrapper = Apadmi::Grout::JiraWrapper.new(username, token, base_url, context_path, project)
+      def self.init_for_jira(
+        username,
+        token,
+        base_url,
+        context_path,
+        project,
+        logger = Apadmi::Grout::DefaultLogger.new
+      )
+        network_service = Apadmi::Grout::NetworkService.init_for_basic_auth(username, token, base_url)
+        jira_board_service = Apadmi::Grout::JiraBoardService.new(username, token, base_url, context_path, project, network_service)
+        git_utils = Apadmi::Grout::GitUtils
+        issues_from_changelog_action = Apadmi::Grout::IssuesFromChangelogAction.new(jira_board_service, "#{project}-", logger)
+
+        DependencyInjector.new(
+          board_service: jira_board_service,
+          move_tickets_action: Apadmi::Grout::MoveTicketsAction.new(jira_board_service, logger),
+          issues_from_changelog_action: issues_from_changelog_action,
+          find_tickets_to_move_action: Apadmi::Grout::FindTicketsToMoveJiraAction.new(jira_board_service, git_utils, issues_from_changelog_action, logger),
+          generate_release_notes_action: Apadmi::Grout::GenerateReleaseNotesAction.new(Apadmi::Grout::JiraIssueClassifier.new)
+        )
+      end
+
+      # @param [String] personal_access_token
+      # @param [String] base_url
+      # @param [Logger] logger
+      def self.init_for_ado(
+        personal_access_token,
+        base_url,
+        logger = Apadmi::Grout::DefaultLogger.new,
+        ado_config = Apadmi::Grout::AdoConfig.new(
+          flag_tag: "FLAGGED"
+        )
+      )
+        ticket_prefix = "#"
+        network_service = Apadmi::Grout::NetworkService.init_for_basic_auth("", personal_access_token, base_url)
+        ado_board_service = Apadmi::Grout::AdoBoardService.new(network_service, ado_config, logger)
+        git_utils = Apadmi::Grout::GitUtils
+        issues_from_changelog_action = Apadmi::Grout::IssuesFromChangelogAction.new(ado_board_service, ticket_prefix, logger)
+
+        DependencyInjector.new(
+          board_service: ado_board_service,
+          move_tickets_action: Apadmi::Grout::MoveTicketsAction.new(ado_board_service, logger),
+          issues_from_changelog_action: issues_from_changelog_action,
+          find_tickets_to_move_action: Apadmi::Grout::FindTicketsToMoveAdoAction.new(ado_board_service, ticket_prefix, git_utils, issues_from_changelog_action,
+                                                                                     logger),
+          generate_release_notes_action: Apadmi::Grout::GenerateReleaseNotesAction.new(Apadmi::Grout::AdoIssueClassifier.new)
+        )
+      end
 
-        @move_jira_tickets_action = Apadmi::Grout::MoveJiraTicketsAction.new(@jira_wrapper, logger)
-        @find_tickets_to_move_action = Apadmi::Grout::FindTicketsToMoveAction.new(@jira_wrapper, logger)
-        @generate_release_notes_action = Apadmi::Grout::GenerateReleaseNotesAction.new(base_url)
-        @issues_from_changelog_action = Apadmi::Grout::IssuesFromChangelogAction.new(@jira_wrapper, logger)
+      def self.bitrise_service(api_token, base_url, app_slug)
+        network_service = Apadmi::Grout::NetworkService.new(api_token, base_url)
+        Apadmi::Grout::BitriseService.new(app_slug, network_service)
       end
     end
   end

data/lib/apadmi/grout/{jira/models/find_tickets_options.rb → models/ado_config.rb}

@@ -2,8 +2,8 @@
 
 module Apadmi
   module Grout
-    FindTicketsOptions = Struct.new(
-      :include_no_sprint_tickets,
+    AdoConfig = Struct.new(
+      :flag_tag,
       keyword_init: true
     )
   end

data/lib/apadmi/grout/models/bitrise.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    STATUS_RUNNING = 0
+    STATUS_SUCCESS = 1
+    STATUS_FAILED = 2
+    STATUS_ABORTED_FAIL = 3
+    STATUS_ABORTED_SUCCESS = 4
+
+    BitriseBuild = Struct.new(:triggered_at, :slug, :status, :commit_hash) do
+      def finished_with_success
+        STATUS_SUCCESS == status
+      end
+    end
+
+    Artifact = Struct.new(:title, :download_url)
+
+    TriggeredBitriseBuild = Struct.new(:build_number, :build_slug, :build_url, :message, :service, :slug, :status, :triggered_workflow) do
+      def finished_with_success
+        STATUS_SUCCESS == status
+      end
+
+      def self.from_json(json)
+        TriggeredBitriseBuild.new(
+          json["build_number"],
+          json["build_slug"],
+          json["build_url"],
+          json["message"],
+          json["service"],
+          json["slug"],
+          json["status"],
+          json["triggered_workflow"]
+        )
+      end
+    end
+  end
+end

data/lib/apadmi/grout/models/find_tickets_options.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # Generic find tickets options
+    class FindTicketsOptions; end
+
+    # Jira specific find tickets options
+    class JiraFindTicketsOptions < FindTicketsOptions
+      attr_reader :include_no_sprint_tickets
+
+      # @param include_no_sprint_tickets [String] whether or not to include tickets with no sprint assigned
+      def initialize(include_no_sprint_tickets: false)
+        @include_no_sprint_tickets = include_no_sprint_tickets
+      end
+
+      def ==(other)
+        other.class == self.class && other.state == state
+      end
+
+      def state
+        [@include_no_sprint_tickets]
+      end
+    end
+
+    # Ado specific find tickets options
+    class AdoFindTicketsOptions < FindTicketsOptions
+      attr_reader :required_tags, :not_tags
+
+      def initialize(required_tags: [], not_tags: [])
+        @required_tags = required_tags
+        @not_tags = not_tags
+      end
+
+      def ==(other)
+        other.class == self.class && other.state == state
+      end
+
+      def state
+        [@required_tags, @not_tags]
+      end
+    end
+  end
+end

data/lib/apadmi/grout/{jira/models → models}/flag_messages.rb

@@ -13,7 +13,8 @@ module Apadmi
       # @return [Apadmi::Grout::FlagMessages]
       def self.default(status)
         FlagMessages.new(
-          "REASON FOR FLAG: Check this ticket - it was put in #{status} but has no PRs connected to it. CI still moved it",
+          "REASON FOR FLAG: Check this ticket - it was put in #{status} but has no PRs connected to it. CI still moved it. " \
+          "(WARNING: this may cause the `fix_versions` to be incorrect)",
           "REASON FOR FLAG: Check this ticket - it was put in #{status} but has no MERGED PRs and at least one OPEN PR",
           "REASON FOR FLAG: Check this ticket - it was put in #{status} but has only DECLINED PRs",
           "REASON FOR FLAG: Check this ticket - it was put in #{status} but has no MERGED PRs"

data/lib/apadmi/grout/models/issue.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    # A generic issue type wrapping up the underlying JIRA & ADO object
+    # @param key [String] Unique key identifying the issue
+    # @param summary [String] The issue title
+    # @param status [String] The current status on the board
+    # @param issue_type [String] Raw string representing issue type e.g "In Progress"
+    # @param url [String] url to the issue
+    # @param raw_object [JIRA::Resource::Issue|Hash] The underlying raw object from the platform
+    Issue = Struct.new(:key, :summary, :status, :issue_type, :url, :raw_object) do
+      # @return [Apadmi::Grout::Issue]
+      def self.from_ado_hash(hash)
+        Issue.new(
+          hash["id"].to_s,
+          hash["fields"]["System.Title"],
+          hash["fields"]["System.State"],
+          hash["fields"]["System.WorkItemType"],
+          hash["url"],
+          hash
+        )
+      end
+
+      # @return [Array<Apadmi::Grout::Issue>]
+      def self.from_ado_hashes(hashes)
+        hashes.map { |h| Issue.from_ado_hash(h) }
+      end
+
+      # @param issue [JIRA::Resource::Issue]
+      # @return [Apadmi::Grout::Issue]
+      def self.from_jira_issue(issue, base_url)
+        Issue.new(
+          issue.key,
+          issue.summary,
+          issue.status.name,
+          issue.issuetype.name,
+          "#{base_url}/browse/#{issue.key}",
+          issue
+        )
+      end
+
+      # @return [Array<Apadmi::Grout::Issue>]
+      def self.from_jira_issues(issues, base_url)
+        issues.map { |i| Issue.from_jira_issue(i, base_url) }
+      end
+    end
+  end
+end