apadmi_grout 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e1366656468880b0537f216f0e6e6d02ac91a8da0a90098f16923bf8b0959a7
-  data.tar.gz: 12a4ea1f4d6a19d229aec128b2e6dce25fdc65333dc88974a9f3caca248a9a6d
+  metadata.gz: 8da866b98ba10eeb0dd9a8a664bd926e8c657cb918bf8a73474d1e3aacd941c4
+  data.tar.gz: '0759b30f1bcbe228e7c1a22eecc52bad02f8174d31584d130936a9d3203d35ef'
 SHA512:
-  metadata.gz: e64db1a7ace678871f6f32a9e2747d62ae854024755b52bbb4caadd474f989fa10cd5151021dde2c9eafb8cf48b7e58633dbcafa2f2e81fddfc088eca0e965dc
-  data.tar.gz: 7bd1bd81f7bc1a24050ed0fe95bc73af8be5765745e5ff3d926728196cbf1b3d96600437f3c08cfa13256cb344b6f746fb0c457b30f0a7a0d22604050337cad4
+  metadata.gz: fd158cbb2bda541b4fbb80137200c60793d86d1257705aec7ffe5450f1fd66a6d8dc13f6e1135ca5c2db28a8049a92db4e1d76b678b0aa745314cdd7bdd92fed
+  data.tar.gz: f0a7a913306577749fcba0a68ce1311e073ce4f21ac0e15d50f87527f7a65a8c27e0f3136e871d7d0b5ab457da99369bc9c99a91007f361f4cb102c435e3751f

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Core Changelog
 
-## [Unreleased]
+## [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
 
 ## [1.0.0] - 2022-05-09 - Initial release
 

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,67 @@
 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.new(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.new("", 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)
 
-        @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)
+        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
     end
   end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    AdoConfig = Struct.new(
+      :flag_tag,
+      keyword_init: true
+    )
+  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/models/flag_messages.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Apadmi
+  module Grout
+    FlagMessages = Struct.new(
+      :no_prs_flag_msg,
+      :open_prs_flag_msg,
+      :declined_prs_flag_msg,
+      :no_merged_prs_flag_msg
+    ) do
+      # Get default flag messages
+      # @param status [String] status ticket will be moving to
+      # @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. " \
+          "(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"
+        )
+      end
+    end
+  end
+end

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