payping-gitlab-triage 0.1.1

data/lib/gitlab/triage/engine.rb

@@ -0,0 +1,635 @@
+require 'active_support/all'
+require 'active_support/inflector'
+
+require_relative 'expand_condition'
+require_relative 'filters/issue_date_conditions_filter'
+require_relative 'filters/merge_request_date_conditions_filter'
+require_relative 'filters/branch_date_filter'
+require_relative 'filters/branch_protected_filter'
+require_relative 'filters/votes_conditions_filter'
+require_relative 'filters/no_additional_labels_conditions_filter'
+require_relative 'filters/author_member_conditions_filter'
+require_relative 'filters/assignee_member_conditions_filter'
+require_relative 'filters/discussions_conditions_filter'
+require_relative 'filters/ruby_conditions_filter'
+require_relative 'limiters/date_field_limiter'
+require_relative 'action'
+require_relative 'policies/rule_policy'
+require_relative 'policies/summary_policy'
+require_relative 'policies_resources/rule_resources'
+require_relative 'policies_resources/summary_resources'
+require_relative 'api_query_builders/date_query_param_builder'
+require_relative 'api_query_builders/single_query_param_builder'
+require_relative 'api_query_builders/multi_query_param_builder'
+require_relative 'url_builders/url_builder'
+require_relative 'network'
+require_relative 'graphql_network'
+require_relative 'rest_api_network'
+require_relative 'network_adapters/httparty_adapter'
+require_relative 'network_adapters/graphql_adapter'
+require_relative 'graphql_queries/query_builder'
+require_relative 'ui'
+
+module Gitlab
+  module Triage
+    class Engine
+      attr_reader :per_page, :policies, :options
+
+      DEFAULT_NETWORK_ADAPTER = Gitlab::Triage::NetworkAdapters::HttpartyAdapter
+      DEFAULT_GRAPHQL_ADAPTER = Gitlab::Triage::NetworkAdapters::GraphqlAdapter
+      ALLOWED_STATE_VALUES = {
+        issues: %w[opened closed],
+        merge_requests: %w[opened closed merged]
+      }.with_indifferent_access.freeze
+      MILESTONE_TIMEBOX_VALUES = %w[none any upcoming started].freeze
+      ITERATION_SELECTION_VALUES = %w[none any].freeze
+      EpicsTriagingForProjectImpossibleError = Class.new(StandardError)
+      MultiPolicyInInjectionModeError = Class.new(StandardError)
+
+      def initialize(policies:, options:, network_adapter_class: DEFAULT_NETWORK_ADAPTER, graphql_network_adapter_class: DEFAULT_GRAPHQL_ADAPTER)
+        options.host_url = policies.delete(:host_url) { options.host_url }
+        options.api_version = policies.delete(:api_version) { 'v4' }
+        options.dry_run = ENV['TEST'] == 'true' if options.dry_run.nil?
+
+        @per_page = policies.delete(:per_page) { 100 }
+        @policies = policies
+        @options = options
+        @network_adapter_class = network_adapter_class
+        @graphql_network_adapter_class = graphql_network_adapter_class
+
+        assert_options!
+
+        @options.source = @options.source.to_s
+
+        require_ruby_files
+      end
+
+      def perform
+        puts "Performing a dry run.\n\n" if options.dry_run
+
+        puts Gitlab::Triage::UI.header("Triaging the `#{options.source_id}` #{options.source.singularize}", char: '=')
+        puts
+
+        resource_rules.each do |resource_type, policy_definition|
+          next unless right_resource_type_for_resource_option?(resource_type)
+
+          assert_epic_rule!(resource_type)
+
+          puts Gitlab::Triage::UI.header("Processing summaries & rules for #{resource_type}", char: '-')
+          puts
+
+          process_summaries(resource_type, policy_definition[:summaries])
+          process_rules(resource_type, policy_definition[:rules])
+        end
+      end
+
+      def network
+        @network ||= Network.new(restapi: restapi_network, graphql: graphql_network)
+      end
+
+      def restapi_network
+        @restapi_network ||= RestAPINetwork.new(network_adapter)
+      end
+
+      def graphql_network
+        @graphql_network ||= GraphqlNetwork.new(graphql_network_adapter)
+      end
+
+      private
+
+      def assert_options!
+        assert_all!
+        assert_source!
+        assert_source_id!
+        assert_resource_reference!
+      end
+
+      # rubocop:disable Style/IfUnlessModifier
+      def assert_all!
+        return unless options.all
+
+        if options.source
+          raise ArgumentError, '--all-projects option cannot be used in conjunction with --source option!'
+        end
+
+        if options.source_id
+          raise ArgumentError, '--all-projects option cannot be used in conjunction with --source-id option!'
+        end
+
+        if options.resource_reference # rubocop:disable Style/GuardClause
+          raise ArgumentError, '--all-projects option cannot be used in conjunction with --resource-reference option!'
+        end
+      end
+      # rubocop:enable Style/IfUnlessModifier
+
+      def assert_source!
+        return if options.source
+        return if options.all
+
+        raise ArgumentError, 'A source is needed (pass it with the `--source` option)!'
+      end
+
+      def assert_source_id!
+        return if options.source_id
+        return if options.all
+
+        raise ArgumentError, 'A project or group ID is needed (pass it with the `--source-id` option)!'
+      end
+
+      def assert_resource_reference!
+        return unless options.resource_reference
+
+        if options.source == 'groups' && !options.resource_reference.start_with?('&')
+          raise ArgumentError, "--resource-reference can only start with '&' when --source=groups is passed ('#{options.resource_reference}' passed)!"
+        end
+
+        if options.source == 'projects' && !options.resource_reference.start_with?('#', '!') # rubocop:disable Style/GuardClause
+          raise(
+            ArgumentError,
+            "--resource-reference can only start with '#' or '!' when --source=projects is passed " \
+            "('#{options.resource_reference}' passed)!"
+          )
+        end
+      end
+
+      def require_ruby_files
+        options.require_files.each(&method(:require))
+      end
+
+      def right_resource_type_for_resource_option?(resource_type)
+        return true unless options.resource_reference
+
+        resource_reference = options.resource_reference
+
+        case resource_type
+        when 'issues'
+          resource_reference.start_with?('#')
+        when 'merge_requests'
+          resource_reference.start_with?('!')
+        when 'epics'
+          resource_reference.start_with?('&')
+        end
+      end
+
+      def assert_epic_rule!(resource_type)
+        return if resource_type != 'epics' || options.source == 'groups'
+
+        raise EpicsTriagingForProjectImpossibleError, "Epics can only be triaged at the group level. Please set the `--source groups` option."
+      end
+
+      def resource_rules
+        @resource_rules ||= policies.delete(:resource_rules) { {} }
+      end
+
+      def network_adapter
+        @network_adapter ||= @network_adapter_class.new(options)
+      end
+
+      def graphql_network_adapter
+        @graphql_network_adapter ||= @graphql_network_adapter_class.new(options)
+      end
+
+      def rule_conditions(rule)
+        rule.fetch(:conditions) { {} }
+      end
+
+      def rule_limits(rule)
+        rule.fetch(:limits) { {} }
+      end
+
+      # Process an array of +summary_definitions+.
+      #
+      # @example Example of an array of summary definitions (shown as YAML for readability).
+      #
+      #   - name: Newest and oldest issues summary
+      #     rules:
+      #       - name: New issues
+      #         conditions:
+      #           state: opened
+      #         limits:
+      #           most_recent: 2
+      #         actions:
+      #           summarize:
+      #             item: "- [ ] [{{title}}]({{web_url}}) {{labels}}"
+      #             summary: |
+      #               Please triage the following new {{type}}:
+      #               {{items}}
+      #     actions:
+      #       summarize:
+      #         title: "Newest and oldest {{type}} summary"
+      #         summary: |
+      #           Please triage the following {{type}}:
+      #           {{items}}
+      #           Please take care of them before the end of #{7.days.from_now.strftime('%Y-%m-%d')}
+      #           /label ~"needs attention"
+      #
+      # @param summary_definitions [Array<Hash>] An array usually given as YAML in a triage policy file.
+      #
+      # @return [nil]
+      def process_summaries(resource_type, summary_definitions)
+        return if summary_definitions.blank?
+
+        summary_definitions.each do |summary_definition|
+          process_summary(resource_type, summary_definition)
+        end
+      end
+
+      # Process an array of +rule_definitions+.
+      #
+      # @example Example of an array of rule definitions.
+      #
+      #   [{ name: "New issues", conditions: { state: opened }, limits: { most_recent: 2 }, actions: { labels: ["needs attention"] } }]
+      #
+      # @param rule_definitions [Array<Hash>] An array usually given as YAML in a triage policy file.
+      #
+      # @return [nil]
+      def process_rules(resource_type, rule_definitions)
+        return if rule_definitions.blank?
+
+        rule_definitions.each do |rule_definition|
+          resources_for_rule(resource_type, rule_definition) do |resources|
+            policy = Policies::RulePolicy.new(
+              resource_type, rule_definition, resources, network)
+
+            process_action(policy)
+          end
+        end
+      end
+
+      # Process a +summary_definition+.
+      #
+      # @example Example of a summary definition hash (shown as YAML for readability).
+      #
+      #   name: Newest and oldest issues summary
+      #   rules:
+      #     - name: New issues
+      #       conditions:
+      #         state: opened
+      #       limits:
+      #         most_recent: 2
+      #       actions:
+      #         summarize:
+      #           item: "- [ ] [{{title}}]({{web_url}}) {{labels}}"
+      #           summary: |
+      #             Please triage the following new {{type}}:
+      #             {{items}}
+      #   actions:
+      #     summarize:
+      #       title: "Newest and oldest {{type}} summary"
+      #       summary: |
+      #         Please triage the following {{type}}:
+      #         {{items}}
+      #         Please take care of them before the end of #{7.days.from_now.strftime('%Y-%m-%d')}
+      #         /label ~"needs attention"
+      #
+      # @param resource_type [String] The resource type, e.g. +issues+ or +merge_requests+.
+      # @param summary_definition [Hash] A hash usually given as YAML in a triage policy file:
+      #
+      # @return [nil]
+      def process_summary(resource_type, summary_definition)
+        puts Gitlab::Triage::UI.header("Processing summary: **#{summary_definition[:name]}**", char: '~')
+        puts
+
+        summary_parts_for_rules(resource_type, summary_definition[:rules]) do |summary_resources|
+          policy = Policies::SummaryPolicy.new(
+            resource_type, summary_definition, summary_resources, network)
+
+          process_action(policy)
+        end
+      end
+
+      # Transform an array of +rule_definitions+ into a +PoliciesResources::SummaryResources.new(rule => rule_resources)+ object.
+      #
+      # @example Example of an array of rule definitions.
+      #
+      #   [{ name: "New issues", conditions: { state: opened }, limits: { most_recent: 2 }, actions: { labels: ["needs attention"] } }]
+      #
+      # @param resource_type [String] The resource type, e.g. +issues+ or +merge_requests+.
+      # @param rule_definitions [Array<Hash>] An array of rule definitions, e.g.
+      #                                       +[{ name: 'Foo', conditions: { milestone: 'v1' } }, { name: 'Foo', conditions: { state: 'opened' } }]+.
+      #
+      # @yieldparam summary_resources [PoliciesResources::SummaryResources] An object which contains a +{ rule_definition => resources }+ hash.
+      # @yieldreturn [nil]
+      #
+      # @return [nil]
+      def summary_parts_for_rules(resource_type, rule_definitions)
+        # { summary_rule => resources }
+        parts = rule_definitions.each_with_object({}) do |rule_definition, result|
+          to_enum(:resources_for_rule, resource_type, rule_definition).each do |rule_resources, expanded_conditions|
+            # We replace the non-expanded rule conditions with the expanded ones
+            result.merge!(rule_definition.merge(conditions: expanded_conditions) => rule_resources)
+          end
+
+          result
+        end
+
+        yield(PoliciesResources::SummaryResources.new(parts))
+      end
+
+      # Transform a non-expanded +rule_definition+ into a +PoliciesResources::RuleResources.new(resources)+ object.
+      #
+      # @example Example of a rule definition hash.
+      #
+      #   { name: "New issues", conditions: { state: opened }, limits: { most_recent: 2 }, actions: { labels: ["needs attention"] } }
+      #
+      # @param resource_type [String] The resource type, e.g. +issues+ or +merge_requests+.
+      # @param rule_definition [Hash] A rule definition, e.g. +{ name: 'Foo', conditions: { milestone: 'v1' } }+.
+      #
+      # @yieldparam rule_resources [PoliciesResources::RuleResources] An object which contains an array of resources.
+      # @yieldparam expanded_conditions [Hash] A hash of expanded conditions.
+      # @yieldreturn [nil]
+      #
+      # @return [nil]
+      def resources_for_rule(resource_type, rule_definition)
+        puts Gitlab::Triage::UI.header("Gathering resources for rule: **#{rule_definition[:name]}**", char: '-')
+
+        ExpandCondition.perform(rule_conditions(rule_definition)) do |expanded_conditions|
+          # retrieving the resources for every rule is inefficient
+          # however, previous rules may affect those upcoming
+          resources = options.resources ||
+            fetch_resources(resource_type, expanded_conditions, rule_definition)
+
+          # In some filters/actions we want to know which resource type it is
+          attach_resource_type(resources, resource_type)
+
+          puts "\n\n* Found #{resources.count} resources..."
+          print "* Filtering resources..."
+          resources = filter_resources(resources, expanded_conditions)
+          puts "\n* Total after filtering: #{resources.count} resources"
+          print "* Limiting resources..."
+          resources = limit_resources(resources, rule_limits(rule_definition))
+          puts "\n* Total after limiting: #{resources.count} resources"
+          puts
+
+          yield(PoliciesResources::RuleResources.new(resources), expanded_conditions)
+        end
+      end
+
+      def fetch_resources(resource_type, expanded_conditions, rule_definition)
+        resources = []
+
+        if rule_definition[:api] == 'graphql'
+          graphql_query_options = { source: source_full_path }
+
+          if options.resource_reference
+            expanded_conditions[:iids] = options.resource_reference[1..]
+            graphql_query_options[:iids] = [expanded_conditions[:iids]]
+          end
+
+          graphql_query = build_graphql_query(resource_type, expanded_conditions, true)
+
+          resources = graphql_network.query(graphql_query, **graphql_query_options)
+        else
+          # FIXME: Epics listing endpoint doesn't support filtering by `iids`, so instead we
+          # get a single epic when `--resource-reference` is given for epics.
+          # Because of that, the query could return a single epic, so we make sure we get an array.
+          resources = Array(network.query_api(build_get_url(resource_type, expanded_conditions)))
+
+          iids = resources.pluck('iid').map(&:to_s)
+          expanded_conditions[:iids] = iids
+
+          graphql_query = build_graphql_query(resource_type, expanded_conditions)
+          graphql_resources = graphql_network.query(graphql_query, source: source_full_path, iids: iids) if graphql_query.any?
+
+          decorate_resources_with_graphql_data(resources, graphql_resources)
+        end
+
+        resources
+      end
+
+      def attach_resource_type(resources, resource_type)
+        resources.each { |resource| resource[:type] = resource_type }
+      end
+
+      def decorate_resources_with_graphql_data(resources, graphql_resources)
+        return if graphql_resources.nil?
+
+        graphql_resources_by_id = graphql_resources.to_h { |resource| [resource[:id], resource] }
+        resources.each { |resource| resource.merge!(graphql_resources_by_id[resource[:id]].to_h) }
+      end
+
+      def process_action(policy)
+        Action.process(
+          policy: policy,
+          network: network,
+          dry: options.dry_run)
+        puts
+      end
+
+      def filter_resources(resources, conditions) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
+        resources.select do |resource|
+          results = []
+
+          # rubocop:disable Style/IfUnlessModifier
+          if conditions[:date]
+            case resource[:type]
+            when 'branches'
+              results << Filters::BranchDateFilter.new(resource, conditions[:date]).calculate
+            when 'issues'
+              if conditions.dig(:date, :filter_in_ruby)
+                results << Filters::IssueDateConditionsFilter.new(resource, conditions[:date]).calculate
+              end
+            when 'merge_requests'
+              if conditions.dig(:date, :filter_in_ruby) ||
+                  # REST API does not support filtering with merged_at,
+                  # so we have to filter it in Ruby
+                  conditions.dig(:date, :attribute) == 'merged_at'
+                results << Filters::MergeRequestDateConditionsFilter.new(resource, conditions[:date]).calculate
+              end
+            end
+          end
+
+          if resource[:type] == 'branches'
+            results << Filters::BranchProtectedFilter.new(resource, conditions[:protected]).calculate
+          end
+
+          votes_condition = conditions[:votes] || conditions[:upvotes]
+          if votes_condition
+            results << Filters::VotesConditionsFilter.new(resource, votes_condition).calculate
+          end
+
+          if conditions[:no_additional_labels]
+            results << Filters::NoAdditionalLabelsConditionsFilter.new(resource, conditions.fetch(:labels) { [] }).calculate
+          end
+
+          if conditions[:author_member]
+            results << Filters::AuthorMemberConditionsFilter.new(resource, conditions[:author_member], network).calculate
+          end
+
+          if conditions[:assignee_member]
+            results << Filters::AssigneeMemberConditionsFilter.new(resource, conditions[:assignee_member], network).calculate
+          end
+
+          if conditions[:discussions]
+            results << Filters::DiscussionsConditionsFilter.new(resource, conditions[:discussions]).calculate
+          end
+
+          if conditions[:ruby]
+            results << Filters::RubyConditionsFilter.new(resource, conditions, network).calculate
+          end
+          # rubocop:enable Style/IfUnlessModifier
+
+          results.all?
+        end
+      end
+
+      def limit_resources(resources, limits)
+        if limits.empty?
+          resources
+        else
+          Limiters::DateFieldLimiter.new(resources, limits).limit
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def build_get_url(resource_type, conditions)
+        # Example issues query with state and labels
+        # https://gitlab.com/api/v4/projects/test-triage%2Fissue-project/issues?state=open&labels=project%20label%20with%20spaces,group_label_no_spaces
+        params = {
+          per_page: per_page
+        }
+
+        condition_builders = []
+        condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('iids', options.resource_reference[1..]) if options.resource_reference
+
+        condition_builders << APIQueryBuilders::MultiQueryParamBuilder.new('labels', conditions[:labels], ',') if conditions[:labels]
+
+        if conditions[:forbidden_labels]
+          condition_builders << APIQueryBuilders::MultiQueryParamBuilder.new('not[labels]', conditions[:forbidden_labels], ',')
+        end
+
+        if conditions[:state]
+          condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new(
+            'state',
+            conditions[:state],
+            allowed_values: ALLOWED_STATE_VALUES[resource_type])
+        end
+
+        condition_builders << milestone_condition_builder(resource_type, conditions[:milestone]) if conditions[:milestone]
+
+        if conditions[:date] && APIQueryBuilders::DateQueryParamBuilder.applicable?(conditions[:date]) && resource_type&.to_sym != :branches
+          condition_builders << APIQueryBuilders::DateQueryParamBuilder.new(conditions.delete(:date))
+        end
+
+        case resource_type&.to_sym
+        when :issues
+          condition_builders.concat(issues_resource_query(conditions))
+        when :merge_requests
+          condition_builders.concat(merge_requests_resource_query(conditions))
+        when :branches
+          condition_builders.concat(branches_resource_query(conditions))
+        end
+
+        condition_builders.compact.each do |condition_builder|
+          params[condition_builder.param_name] = condition_builder.param_content
+        end
+
+        url_builder_options = {
+          network_options: options,
+          all: options.all,
+          source: options.source,
+          source_id: options.source_id,
+          resource_type: resource_type,
+          params: params
+        }
+
+        # FIXME: Epics listing endpoint doesn't support filtering by `iids`, so instead we
+        # get a single epic when `--resource-reference` is given for epics.
+        url_builder_options[:resource_id] = options.resource_reference[1..] if options.resource_reference && resource_type == 'epics'
+
+        UrlBuilders::UrlBuilder.new(url_builder_options).build
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def milestone_condition_builder(resource_type, milestone_condition)
+        milestone_value = Array(milestone_condition)[0].to_s # back-compatibility
+        return if milestone_value.empty?
+
+        # Issues API should use the `milestone_id` param for timebox values, and `milestone` for milestone title
+        args =
+          if resource_type.to_sym == :issues && MILESTONE_TIMEBOX_VALUES.include?(milestone_value.downcase)
+            ['milestone_id', milestone_value.titleize] # The API only accepts titleized values.
+          else
+            ['milestone', milestone_value]
+          end
+
+        APIQueryBuilders::SingleQueryParamBuilder.new(*args)
+      end
+
+      def iteration_condition_builder(iteration_value)
+        # Issues API should use the `iteration_id` param for timebox values, and `iteration_title` for iteration title
+        args =
+          if ITERATION_SELECTION_VALUES.include?(iteration_value.downcase)
+            ['iteration_id', iteration_value.titleize] # The API only accepts titleized values.
+          else
+            ['iteration_title', iteration_value]
+          end
+        APIQueryBuilders::SingleQueryParamBuilder.new(*args)
+      end
+
+      def issues_resource_query(conditions)
+        [].tap do |condition_builders|
+          condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('weight', conditions[:weight]) if conditions[:weight]
+          condition_builders << iteration_condition_builder(conditions[:iteration]) if conditions[:iteration]
+          condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('health_status', conditions[:health_status]) if conditions[:health_status]
+        end
+      end
+
+      def merge_requests_resource_query(conditions)
+        [].tap do |condition_builders|
+          [
+            :source_branch,
+            :target_branch,
+            :reviewer_id
+          ].each do |key|
+            condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new(key.to_s, conditions[key]) if conditions[key]
+          end
+          condition_builders << draft_condition_builder(conditions[:draft]) if conditions.key?(:draft)
+        end
+      end
+
+      def branches_resource_query(conditions)
+        [].tap do |condition_builders|
+          condition_builders << APIQueryBuilders::SingleQueryParamBuilder.new('search', conditions[:name]) if conditions[:name]
+        end
+      end
+
+      def draft_condition_builder(draft_condittion)
+        # Issues API only accepts 'yes' and 'no' as strings: https://docs.gitlab.com/ee/api/merge_requests.html
+        wip =
+          case draft_condittion
+          when true
+            'yes'
+          when false
+            'no'
+          else
+            raise ArgumentError, 'The "draft" condition only accepts true or false.'
+          end
+
+        APIQueryBuilders::SingleQueryParamBuilder.new('wip', wip)
+      end
+
+      def build_graphql_query(resource_type, conditions, graphql_only = false)
+        Gitlab::Triage::GraphqlQueries::QueryBuilder
+          .new(options.source, resource_type, conditions, graphql_only: graphql_only)
+      end
+
+      def source_full_path
+        @source_full_path ||= fetch_source_full_path
+      end
+
+      def fetch_source_full_path
+        return options.source_id unless /\A\d+\z/.match?(options.source_id)
+
+        source_details = network.query_api(build_get_url(nil, {})).first
+        full_path = source_details['full_path'] || source_details['path_with_namespace']
+
+        raise ArgumentError, 'A source with given source_id was not found!' if full_path.blank?
+
+        full_path
+      end
+    end
+  end
+end

data/lib/gitlab/triage/entity_builders/issue_builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../command_builders/text_content_builder'
+
+module Gitlab
+  module Triage
+    module EntityBuilders
+      class IssueBuilder
+        attr_reader :destination
+
+        def initialize(
+          type:, action:, resource:, network:,
+          policy_spec: {}, separator: "\n")
+          @type = type
+          @policy_spec = policy_spec
+          @item_template = action[:item]
+          @title_template = action[:title]
+          @description_template = action[:description]
+          @destination = action[:destination]
+          @redact_confidentials =
+            action[:redact_confidential_resources] != false
+          @resource = resource
+          @network = network
+          @separator = separator
+        end
+
+        def title
+          @title ||= build_text(@title_template)
+        end
+
+        def description
+          @description ||= build_text(@description_template)
+        end
+
+        def valid?
+          title =~ /\S+/
+        end
+
+        private
+
+        def build_text(template)
+          return '' unless template
+
+          CommandBuilders::TextContentBuilder.new(
+            template,
+            resource: @resource,
+            network: @network,
+            redact_confidentials: @redact_confidentials)
+            .build_command.chomp
+        end
+      end
+    end
+  end
+end