apadmi_grout 1.2.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a8f0b024bb98a0372b85755e14bc753370328418273d6e0d07aba74f664bb9a
-  data.tar.gz: '04286d3e985378d78f1dec57c220f1a4a5ec35d90ccf4a407d3dde66f75f9a6d'
+  metadata.gz: 01621f3c2ed3d2ca284e8f7778bdff16ed635a8bb25a2bae11c79962ce1d9d00
+  data.tar.gz: e480a79994bff440381d288826315960900909d2b7d94b3ec4e36415d13420b2
 SHA512:
-  metadata.gz: 2c9d6d5fce5da1ffaa1ab71a7f54e4bba85a3f4fda470b0613049a2169ca9466d180b655c3129561e9046fe3d0a4041b85c2cf25d70dfd8ac7f521b70a6d5113
-  data.tar.gz: 13b59090e27577e87f7a52ef9dbcc085db1af1b0575a20e98642669155b0652e0e91976a4943f027e33c25d325fe0aa205afa481d761b7a944f5aebf3bf4138a
+  metadata.gz: d6e74bc59d0434dea89aea4f35b593d3b59f85bca8bbb1f003f53b287ba0c4ebdf02aa246c66da327579c4eb174ee7f1df504022ad034b121b1b2ee7e878f82f
+  data.tar.gz: 8d173b1f108f290be9d554c95201c469d34d20989d8826d4a9020e31ff645d85e9075e374300a4d42f93e22cc000ab4bbdadd713623787975869fae9cf318dea

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Core Changelog
 
+## [2.2.0] - 2022-08-16
+* Bumped min ruby version to 3.0.0 to prevent subtle bugs
+* Removed references to JIRA in default release note templates
+* Fixed issues with git warnings being treated like errors
+
+## [2.1.0] - 2022-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.
 

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/{jira/actions/find_tickets_to_move_action.rb → actions/find_tickets_to_move_action/find_tickets_to_move_jira_action.rb}

@@ -13,13 +13,13 @@ module Apadmi
     # 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 FindTicketsToMoveAction
-      # @param [Apadmi::Grout::JiraWrapper]
+    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_wrapper, git_utils, issues_from_chnglg, logger)
-        @jira_wrapper = jira_wrapper
+      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
@@ -29,8 +29,8 @@ module Apadmi
       # @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::FindTicketsOptions]
-      # @return [Array<JIRA::Resource::Issue>] the issues ready to move
+      # @param options [Apadmi::Grout::JiraFindTicketsOptions]
+      # @return [Array<Apadmi::Grout::Issue>] the issues ready to move
       def run(
         component,
         status,
@@ -39,11 +39,10 @@ module Apadmi
         options = nil
       )
         custom_flag_messages ||= Apadmi::Grout::FlagMessages.default(status)
-        options ||= Apadmi::Grout::FindTicketsOptions.new(include_no_sprint_tickets: false)
+        options ||= Apadmi::Grout::JiraFindTicketsOptions.new(include_no_sprint_tickets: false)
 
-        issues = @jira_wrapper.search_unblocked_issues(
-          component, status, [],
-          allow_no_sprint: options.include_no_sprint_tickets
+        issues = @jira_board_service.search_unblocked_issues(
+          component, status, [], options
         ).reject do |issue|
           excluded_ticket_keys.include? issue.key
         end
@@ -68,7 +67,7 @@ module Apadmi
 
       private
 
-      # @param issue [JIRA::Resource::Issue]
+      # @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)
@@ -84,27 +83,27 @@ module Apadmi
         pr_status != PrStatus::UN_INCLUDED
       end
 
-      # @param issue [JIRA::Resource::Issue]
+      # @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_wrapper.get_ticket_prs(issue)
+        prs = @jira_board_service.get_ticket_prs(issue)
 
         if prs.empty?
           @logger.message("#{issue.key} has no PRs. Flagging it: STILL MOVABLE")
-          @jira_wrapper.flag_ticket(issue.key, custom_flag_messages.no_prs_flag_msg)
+          @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_wrapper.flag_ticket(issue.key, custom_flag_messages.open_prs_flag_msg)
+          @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_wrapper.flag_ticket(issue.key, custom_flag_messages.declined_prs_flag_msg)
+          @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_wrapper.flag_ticket(issue.key, custom_flag_messages.no_merged_prs_flag_msg)
+          @jira_board_service.flag_ticket(issue.key, custom_flag_messages.no_merged_prs_flag_msg)
           return PrStatus::UN_INCLUDED
         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,26 +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
 
       # @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,23 +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
-        @move_jira_tickets_action = Apadmi::Grout::MoveJiraTicketsAction.new(@jira_wrapper, logger)
-        @issues_from_changelog_action = Apadmi::Grout::IssuesFromChangelogAction.new(@jira_wrapper, logger)
-        @find_tickets_to_move_action = Apadmi::Grout::FindTicketsToMoveAction.new(@jira_wrapper, git_utils, issues_from_changelog_action, logger)
-        @generate_release_notes_action = Apadmi::Grout::GenerateReleaseNotesAction.new(base_url)
+        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
+
+      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/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