Make organization related project archival features compatible with group archival

Prerequisite

Before you start, please check out the parent epic description to get the full context: Make project archival features compatible with ... (&19690)

Description

We ran a search for "archive" and "archival" in the codebase and pulled together the following relevant results for the grouporganizations domain. We'd need your help with:

1. Review the search results and update the code to use our new ancestor-aware methods and scopes wherever needed
2. Creating new services/workers wherever they're needed
3. Note: Not all "archive" mentions are about project archival – feel free to skip anything that's not relevant!

Archive/Archival Occurrences

Groups & Projects

1. ee/app/models/ee/namespace.rb

   • relation = relation.not_aimed_for_deletion.non_archived if only_active

2. app/helpers/explore_helper.rb

   • archived: params[:archived],

3. app/services/projects/autocomplete_service.rb

   • super(target, project_id: project.id, include_ancestor_groups: true, archived: false)

4. app/models/project.rb

   • after_save :invalidate_namespace_cache, if: :saved_change_to_archived?
   • scope :archived, -> { where(archived: true) }
   • scope :non_archived, -> { where(archived: false) }
   • non_archived.fuzzy_search(query, [:name])
   • .where(archived: false)
   • def archived

5. app/models/namespace.rb

   • has_many :non_archived_projects, -> { where.not(archived: true) }, class_name: 'Project'
   • delegate :archived, :archived=
   • scope :archived, -> { joins(:namespace_settings).where(namespace_settings: { archived: true }) }
   • scope :non_archived, -> { joins(:namespace_settings).where(namespace_settings: { archived: false }) }

6. app/models/group.rb

   • scope :active, -> { non_archived.not_aimed_for_deletion }
   • #{reflections['namespace_settings'].table_name}.archived = TRUE
   • scope :with_non_archived_projects, -> { includes(:non_archived_projects) }
   • left_joins(:non_archived_projects).group(:id).count(:projects)

7. app/models/namespaces/descendants.rb

   • all_project_ids:, all_unarchived_project_ids:, outdated_at: nil)
   • all_project_ids, all_unarchived_project_ids, outdated_at, calculated_at)
   • all_unarchived_project_ids = EXCLUDED.all_unarchived_project_ids,
   • all_unarchived_project_ids,

8. app/models/namespaces/traversal/cached.rb

   • override :all_unarchived_project_ids
   • def all_unarchived_project_ids
   • all_projects.self_and_ancestors_non_archived.select(:id),
   • Namespaces::Descendants.arel_table[:all_unarchived_project_ids]

9. app/models/namespaces/traversal/recursive.rb

   • def all_unarchived_project_ids
   • Project.self_and_ancestors_non_archived.where(namespace: namespace).select(:id)
   • alias_method :recursive_all_unarchived_project_ids, :all_unarchived_project_ids

10. app/models/concerns/loaded_in_group_list.rb

    • def with_counts(archived: nil, active: nil)
    • projects_cte = projects_cte(archived, active)
    • subgroups_cte = subgroups_cte(archived, active)
    • def with_selects_for_list(archived: nil, active: nil)
    • .with_counts(archived:, active:)
    • def by_archived(relation, archived)
    • return relation if archived.nil?
    • def projects_cte(archived = nil, active = nil)
    • projects = by_archived(projects, archived)
    • def subgroups_cte(archived = nil, active = nil)
    • subgroups = by_archived(subgroups, archived)
    • @project_count ||= try(:preloaded_project_count) || projects.non_archived.count

11. app/models/user.rb

    • authorized_projects(Gitlab::Access::PLANNER).non_archived.with_issues_enabled
    • non_archived: true,
    • non_archived: true,
    • params = { reviewer_id: id, state: 'opened', non_archived: true, review_states: %w[unapproved unreviewed review_started] }
    • IssuesFinder.new(self, assignee_id: self.id, state: 'opened', non_archived: true).execute.count

12. app/finders/joined_groups_finder.rb

    • .with_non_archived_projects

13. app/finders/admin/projects_finder.rb

    • items = by_archived(items)
    • def by_archived(items)
    • if params[:archived] == 'only'
    • items.archived
    • elsif params[:archived].blank?
    • items.non_archived

14. app/finders/namespaces/projects_finder.rb

    • # include_archived: boolean
    • # archived_only: boolean
    • collection = by_archived(collection)
    • def by_archived(items)
    • return items.archived if Gitlab::Utils.to_boolean(params[:archived_only], default: false)
    • return items if Gitlab::Utils.to_boolean(params[:include_archived], default: true)
    • items.non_archived

15. app/finders/group_descendants_finder.rb

    • .with_selects_for_list(archived: params[:archived], active: params[:active])
    • .with_selects_for_list(archived: params[:archived], active: params[:active])
    • groups.with_selects_for_list(archived: params[:archived], active: params[:active]).order_by(sort)

16. ee/app/models/ee/organizations/organization.rb

    • -> { non_archived },

17. app/graphql/resolvers/namespace_projects_resolver.rb

    • argument :include_archived, GraphQL::Types::Boolean,
    • description: 'Include also archived projects.'
    • argument :archived_only, GraphQL::Types::Boolean,
    • description: "Return only archived projects."
    • include_archived: args[:include_archived],
    • archived_only: args[:archived_only]

18. app/controllers/groups/children_controller.rb

    • archived: Gitlab::Utils.to_boolean(safe_params[:archived], default: safe_params[:archived]),

19. app/controllers/dashboard/application_controller.rb

    • @projects ||= current_user.authorized_projects.sorted_by_activity.non_archived

20. app/controllers/dashboard/projects_controller.rb

    • before_action :set_non_archived_param, only: [:index]
    • return redirect_to inactive_dashboard_projects_path if params[:archived] == "only"

21. app/controllers/explore/projects_controller.rb

    • before_action :set_non_archived_param

22. app/controllers/groups_controller.rb

    • .non_archived

23. app/controllers/concerns/params_backward_compatibility.rb

    • def set_non_archived_param
    • params[:non_archived] = params[:archived].blank?

24. app/controllers/concerns/group_tree.rb

    • @groups = groups.with_selects_for_list(archived: safe_params[:archived], active: safe_params[:active])
    • archived: Gitlab::Utils.to_boolean(params[:archived], default: params[:archived])
    • ).permit(:sort, :filter, :parent_id, :page, :archived, :active)

25. app/helpers/projects_helper.rb

    • is_project_archived: project.archived.to_s,
    • project.persisted? && !project.self_deletion_scheduled? && can?(current_user, :archive_project, project)
    • def project_archive_settings_app_data(project)
    • help_path: help_page_path('user/project/working_with_projects.md', anchor: 'archive-a-project')
    • def project_unarchive_settings_app_data(project)
    • ancestors_archived: project.ancestors_archived?.to_s,
    • help_path: help_page_path('user/project/working_with_projects.md', anchor: 'unarchive-a-project')

26. app/helpers/groups_helper.rb

    • def group_archive_settings_app_data(group)
    • def group_unarchive_settings_app_data(group)
    • ancestors_archived: group.ancestors_archived?.to_s
    • MergeRequestsFinder.new(current_user, group_id: group.id, include_subgroups: true, non_archived: true).execute

27. app/helpers/namespaces/deletable_helper.rb

    • } => group.all_projects.non_archived,
    • n_('%{count} archived project', '%{count} archived projects', count)
    • } => group.all_projects.archived

28. app/services/groups/merge_requests_count_service.rb

    • .new(user, group_id: group.id, state: 'opened', non_archived: true, include_subgroups: true)

29. ee/app/policies/ee/group_policy.rb

    • @subject.all_projects.non_archived.not_aimed_for_deletion.exists?

30. ee/app/models/concerns/ee/loaded_in_group_list.rb

    • def with_selects_for_list(archived: nil, active: nil)

31. ee/app/helpers/ee/projects_helper.rb

    • group.projects.not_aimed_for_deletion.non_archived
    • .non_archived

32. lib/sidebars/projects/menus/settings_menu.rb

    • if context.project.archived? || !context.project.feature_available?(:builds, context.current_user)
    • if context.project.archived? || !can?(context.current_user, :admin_operations, context.project)

33. lib/api/helpers.rb

    • finder_params[:archived] = archived_param unless params[:archived].nil?
    • def archived_param
    • return 'only' if params[:archived]
    • params[:archived]

34. ee/app/models/ee/group.rb

    • ::Project.for_group_and_its_subgroups(self).non_archived.without_deleted