Add fields selection to export requirement

- Add new argument to GraphQL mutation
- Add permitted fields to export service
- Add specs

app/workers/issuable_export_csv_worker.rb

@@ -10,29 +10,21 @@ class IssuableExportCsvWorker # rubocop:disable Scalability/IdempotentWorker
   def perform(type, current_user_id, project_id, params)
     user = User.find(current_user_id)
     project = Project.find(project_id)
-    finder_params = map_params(params, project_id)
 
-    export_service(type.to_sym, user, project, finder_params).email(user)
+    export_service(type, user, project, params).email(user)
   rescue ActiveRecord::RecordNotFound => error
     logger.error("Failed to export CSV (current_user_id:#{current_user_id}, project_id:#{project_id}): #{error.message}")
   end
 
   private
 
-  def map_params(params, project_id)
-    params
-      .symbolize_keys
-      .except(:sort)
-      .merge(project_id: project_id)
-  end
-
   def export_service(type, user, project, params)
-    issuable_class = service_classes_for(type)
-    issuables = issuable_class[:finder].new(user, params).execute
-    issuable_class[:service].new(issuables, project)
+    issuable_classes = issuable_classes_for(type.to_sym)
+    issuables = issuable_classes[:finder].new(user, parse_params(params, project.id)).execute
+    issuable_classes[:service].new(issuables, project)
   end
 
-  def service_classes_for(type)
+  def issuable_classes_for(type)
     case type
     when :issue
       { finder: IssuesFinder, service: Issues::ExportCsvService }
@@ -43,6 +35,13 @@ class IssuableExportCsvWorker # rubocop:disable Scalability/IdempotentWorker
     end
   end
 
+  def parse_params(params, project_id)
+    params
+      .symbolize_keys
+      .except(:sort)
+      .merge(project_id: project_id)
+  end
+
   def type_error_message(type)
     "Type parameter must be :issue or :merge_request, it was #{type}"
   end

doc/api/graphql/reference/gitlab_schema.graphql

@@ -9963,6 +9963,11 @@ input ExportRequirementsInput {
   """
   search: String
 
+  """
+  List of selected requirements fields to be exported.
+  """
+  selectedFields: [String!]
+
   """
   List requirements by sort order.
   """

doc/api/graphql/reference/gitlab_schema.json

@@ -27117,6 +27117,24 @@
               },
               "defaultValue": null
             },
+            {
+              "name": "selectedFields",
+              "description": "List of selected requirements fields to be exported.",
+              "type": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "SCALAR",
+                    "name": "String",
+                    "ofType": null
+                  }
+                }
+              },
+              "defaultValue": null
+            },
             {
               "name": "clientMutationId",
               "description": "A unique identifier for the client performing the mutation.",

ee/app/graphql/mutations/requirements_management/export_requirements.rb

@@ -14,9 +14,30 @@ module Mutations
                required: true,
                description: 'Full project path the requirements are associated with.'
 
+      argument :selected_fields, [GraphQL::STRING_TYPE],
+               required: false,
+               description: 'List of selected requirements fields to be exported.'
+
+      def ready?(**args)
+        if args[:selected_fields].present?
+          invalid_fields =
+            ::RequirementsManagement::MapExportFieldsService.new(args[:selected_fields]).invalid_fields
+
+          if invalid_fields.any?
+            message = "The following fields are incorrect: #{invalid_fields.join(', ')}."\
+              " See https://docs.gitlab.com/ee/user/project/requirements/#exported-csv-file-format"\
+              " for permitted fields."
+            raise Gitlab::Graphql::Errors::ArgumentError, message
+          end
+        end
+
+        super
+      end
+
       def resolve(args)
         project_path = args.delete(:project_path)
         project = authorized_find!(project_path)
+
         IssuableExportCsvWorker.perform_async(:requirement, current_user.id, project.id, args)
 
         {

ee/app/services/requirements_management/export_csv_service.rb

@@ -2,6 +2,12 @@
 
 module RequirementsManagement
   class ExportCsvService < ::Issuable::ExportCsv::BaseService
+    def initialize(issuables_relation, project, fields = [])
+      super(issuables_relation, project)
+
+      @fields = fields
+    end
+
     def email(user)
       Notify.requirements_csv_email(user, project, csv_data, csv_builder.status).deliver_now
     end
@@ -13,16 +19,7 @@ module RequirementsManagement
     end
 
     def header_to_value_hash
-      {
-        'Requirement ID' => 'iid',
-        'Title' => 'title',
-        'Description' => 'description',
-        'Author' => -> (requirement) { requirement.author&.name },
-        'Author Username' => -> (requirement) { requirement.author&.username },
-        'Created At (UTC)' => -> (requirement) { requirement.created_at.utc },
-        'State' => -> (requirement) { requirement.last_test_report_state == 'passed' ? 'Satisfied' : '' },
-        'State Updated At (UTC)' => -> (requirement) { requirement.latest_report&.created_at&.utc }
-      }
+      RequirementsManagement::MapExportFieldsService.new(@fields).execute
     end
   end
 end

ee/app/services/requirements_management/map_export_fields_service.rb

+# frozen_string_literal: true
+
+module RequirementsManagement
+  class MapExportFieldsService < BaseService
+    attr_reader :fields
+
+    def initialize(fields)
+      @fields = fields
+    end
+
+    def execute
+      return header_to_value_hash if fields.empty?
+
+      selected_fields_to_hash
+    end
+
+    def invalid_fields
+      fields.reject { |field| permitted_field?(field) }
+    end
+
+    private
+
+    def header_to_value_hash
+      @header_to_value_hash ||= {
+        'Requirement ID' => 'iid',
+        'Title' => 'title',
+        'Description' => 'description',
+        'Author' => -> (requirement) { requirement.author&.name },
+        'Author Username' => -> (requirement) { requirement.author&.username },
+        'Created At (UTC)' => -> (requirement) { requirement.created_at.utc },
+        'State' => -> (requirement) { requirement.last_test_report_state == 'passed' ? 'Satisfied' : '' },
+        'State Updated At (UTC)' => -> (requirement) { requirement.latest_report&.created_at&.utc }
+      }
+    end
+
+    def selected_fields_to_hash
+      header_to_value_hash.select { |key| requested_field?(key) }
+    end
+
+    def requested_field?(field)
+      field.downcase.in?(fields.map(&:downcase))
+    end
+
+    def permitted_field?(field)
+      field.downcase.in?(keys.map(&:downcase))
+    end
+
+    def keys
+      header_to_value_hash.keys
+    end
+  end
+end

ee/app/workers/ee/issuable_export_csv_worker.rb

@@ -9,8 +9,18 @@ module EE
 
     private
 
-    override :service_classes_for
-    def service_classes_for(type)
+    override :export_service
+    def export_service(type, user, project, params)
+      return super unless type == :requirement
+
+      fields = params.with_indifferent_access.delete(:selected_fields) || []
+      issuable_classes = issuable_classes_for(type.to_sym)
+      issuables = issuable_classes[:finder].new(user, parse_params(params, project.id)).execute
+      issuable_classes[:service].new(issuables, project, fields)
+    end
+
+    override :issuable_classes_for
+    def issuable_classes_for(type)
       return super unless type == :requirement
 
       { finder: ::RequirementsManagement::RequirementsFinder, service: ::RequirementsManagement::ExportCsvService }

ee/changelogs/unreleased/290823-allow-selecting-fields-for-requirements-export-be.yml

+---
+title: 'Allows fields selection when exporting Requirements with GraphQL'
+merge_request: 52706
+author:
+type: added

ee/spec/graphql/mutations/requirements_management/export_requirements_spec.rb

@@ -5,10 +5,33 @@ require 'spec_helper'
 RSpec.describe Mutations::RequirementsManagement::ExportRequirements do
   let_it_be(:project) { create(:project) }
   let_it_be(:user) { create(:user) }
-  let_it_be(:requirement) { create(:requirement, project: project) }
+  let(:fields) { [] }
+  let(:args) do
+    {
+      project_path: project.full_path,
+      author_username: user.username,
+      state: 'OPENED',
+      search: 'foo',
+      selected_fields: fields
+    }
+  end
 
   subject(:mutation) { described_class.new(object: nil, context: { current_user: user }, field: nil) }
 
+  describe '#ready' do
+    context 'with selected fields argument' do
+      let(:fields) { ['title', 'description', 'created at', 'username'] }
+
+      it 'raises exception when invalid fields are given' do
+        expect { mutation.ready?(**args) }
+          .to raise_error(Gitlab::Graphql::Errors::ArgumentError,
+            "The following fields are incorrect: created at, username."\
+            " See https://docs.gitlab.com/ee/user/project/requirements/#exported-csv-file-format"\
+            " for permitted fields.")
+      end
+    end
+  end
+
   describe '#resolve' do
     shared_examples 'requirements not available' do
       it 'raises a not accessible error' do
@@ -16,18 +39,11 @@ RSpec.describe Mutations::RequirementsManagement::ExportRequirements do
       end
     end
 
-    subject do
-      mutation.resolve(
-        project_path: project.full_path,
-        author_username: user.username,
-        state: 'OPENED',
-        search: 'foo'
-      )
-    end
+    subject { mutation.resolve(**args) }
 
     it_behaves_like 'requirements not available'
 
-    context 'when the user can update the requirement' do
+    context 'when the user can export requirements' do
       before do
         project.add_developer(user)
       end
@@ -37,11 +53,9 @@ RSpec.describe Mutations::RequirementsManagement::ExportRequirements do
           stub_licensed_features(requirements: true)
         end
 
-        it 'export requirements' do
-          args = { author_username: user.username, state: 'OPENED', search: 'foo' }
-
+        it 'exports requirements' do
           expect(IssuableExportCsvWorker).to receive(:perform_async)
-            .with(:requirement, user.id, project.id, args)
+            .with(:requirement, user.id, project.id, args.except(:project_path))
 
           subject
         end

ee/spec/services/requirements_management/export_csv_service_spec.rb

@@ -7,8 +7,9 @@ RSpec.describe RequirementsManagement::ExportCsvService do
   let_it_be(:group) { create_default(:group) }
   let_it_be(:project) { create_default(:project, :public) }
   let_it_be_with_reload(:requirement) { create(:requirement, state: :opened, author: user) }
+  let(:fields) { [] }
 
-  subject { described_class.new(RequirementsManagement::Requirement.all, project) }
+  subject { described_class.new(RequirementsManagement::Requirement.all, project, fields) }
 
   before do
     stub_licensed_features(requirements: true)
@@ -37,7 +38,7 @@ RSpec.describe RequirementsManagement::ExportCsvService do
   end
 
   context 'includes' do
-    let_it_be(:report) { create(:test_report, requirement: requirement, state: :failed, build: nil, author: user) }
+    let_it_be(:report) { create(:test_report, requirement: requirement, state: :passed, build: nil, author: user) }
     let(:time_format) { '%Y-%m-%d %H:%M:%S %Z' }
 
     it 'includes the columns required for import' do
@@ -95,5 +96,18 @@ RSpec.describe RequirementsManagement::ExportCsvService do
         expect(csv[0]['State Updated At (UTC)']).to eq report.created_at.utc.strftime(time_format)
       end
     end
+
+    context 'when selected fields are present' do
+      let(:fields) { ['Title', 'Author username', 'created at', 'state', 'State updated At (UTC)'] }
+
+      it 'returns data for requested fields' do
+        expect(csv[0].to_hash).to eq(
+          'Title' => requirement.title,
+          'Author Username' => requirement.author.username,
+          'State' => 'Satisfied',
+          'State Updated At (UTC)' => report.created_at.utc.strftime(time_format)
+        )
+      end
+    end
   end
 end

ee/spec/services/requirements_management/map_export_fields_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RequirementsManagement::MapExportFieldsService do
+  let(:selected_fields) { ['Title', 'Author username', 'state'] }
+  let(:invalid_fields) { ['Title', 'Author Username', 'State', 'Invalid Field', 'Other Field'] }
+  let(:available_fields) do
+    [
+      'Requirement ID',
+      'Title',
+      'Description',
+      'Author',
+      'Author Username',
+      'Created At (UTC)',
+      'State',
+      'State Updated At (UTC)'
+    ]
+  end
+
+  describe '#execute' do
+    it 'returns a hash with selected fields only' do
+      result = described_class.new(selected_fields).execute
+
+      expect(result).to be_a(Hash)
+      expect(result.keys).to match_array(selected_fields.map(&:titleize))
+    end
+
+    context 'when the fields collection is empty' do
+      it 'returns a hash with all fields' do
+        result = described_class.new([]).execute
+
+        expect(result).to be_a(Hash)
+        expect(result.keys).to match_array(available_fields)
+      end
+    end
+
+    context 'when fields collection includes invalid fields' do
+      it 'returns a hash with valid selected fields only' do
+        result = described_class.new(invalid_fields).execute
+
+        expect(result).to be_a(Hash)
+        expect(result.keys).to eq(selected_fields.map(&:titleize))
+      end
+    end
+  end
+
+  describe '#invalid_fields' do
+    it 'returns an array containing invalid fields' do
+      result = described_class.new(invalid_fields).invalid_fields
+
+      expect(result).to match_array(['Invalid Field', 'Other Field'])
+    end
+  end
+end

ee/spec/workers/ee/issuable_export_csv_worker_spec.rb

@@ -17,7 +17,8 @@ RSpec.describe IssuableExportCsvWorker do
     end
 
     it 'calls the Requirements export service' do
-      expect(RequirementsManagement::ExportCsvService).to receive(:new).with(anything, project).once.and_call_original
+      expect(RequirementsManagement::ExportCsvService)
+        .to receive(:new).with(anything, project, []).once.and_call_original
 
       subject
     end
@@ -28,6 +29,19 @@ RSpec.describe IssuableExportCsvWorker do
       subject
     end
 
+    context 'with selected fields are present' do
+      let(:selected_fields) { %w(Title Description State') }
+
+      it 'calls the Requirements export service with selected fields' do
+        params[:selected_fields] = selected_fields
+
+        expect(RequirementsManagement::ExportCsvService)
+          .to receive(:new).with(anything, project, selected_fields).once.and_call_original
+
+        subject
+      end
+    end
+
     context 'with record not found' do
       let(:logger) { described_class.new.send(:logger) }