SONAR-21058 Add support for collection GET /api/v2/authorizations/groups

15 files changed, 487 insertions, 79 deletions

diff --git a/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupInformation.java b/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupInformation.java
new file mode 100644
index 00000000000..3cf44ba8f5f
--- /dev/null
+++ b/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupInformation.java
@@ -0,0 +1,25 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.common.group.service;
+
+import org.sonar.db.user.GroupDto;
+
+public record GroupInformation(GroupDto groupDto, boolean isManaged, boolean isDefault) {
+}
diff --git a/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupSearchRequest.java b/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupSearchRequest.java
new file mode 100644
index 00000000000..5703dca7e2c
--- /dev/null
+++ b/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupSearchRequest.java
@@ -0,0 +1,31 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.common.group.service;
+
+import javax.annotation.Nullable;
+
+public record GroupSearchRequest(
+  @Nullable String query,
+  @Nullable Boolean managed,
+  int page,
+  int pageSize
+) {
+
+}
diff --git a/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupService.java b/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupService.java
index 4e28d96fcfd..3d9aca02c6e 100644
--- a/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupService.java
+++ b/server/sonar-webserver-common/src/main/java/org/sonar/server/common/group/service/GroupService.java
@@ -19,7 +19,11 @@
  */
 package org.sonar.server.common.group.service;
 
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.api.security.DefaultGroups;
 import org.sonar.api.server.ServerSide;
@@ -29,9 +33,14 @@ import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.permission.GlobalPermission;
 import org.sonar.db.user.GroupDto;
+import org.sonar.db.user.GroupQuery;
+import org.sonar.server.common.SearchResults;
 import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.management.ManagedInstanceService;
+import org.sonar.server.usergroups.DefaultGroupFinder;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static java.lang.Boolean.TRUE;
 import static org.sonar.server.exceptions.BadRequestException.checkRequest;
 
 @ServerSide
@@ -40,9 +49,14 @@ public class GroupService {
   private final DbClient dbClient;
   private final UuidFactory uuidFactory;
 
-  public GroupService(DbClient dbClient, UuidFactory uuidFactory) {
+  private final DefaultGroupFinder defaultGroupFinder;
+  private final ManagedInstanceService managedInstanceService;
+
+  public GroupService(DbClient dbClient, UuidFactory uuidFactory, DefaultGroupFinder defaultGroupFinder, ManagedInstanceService managedInstanceService) {
     this.dbClient = dbClient;
     this.uuidFactory = uuidFactory;
+    this.defaultGroupFinder = defaultGroupFinder;
+    this.managedInstanceService = managedInstanceService;
   }
 
   public Optional<GroupDto> findGroup(DbSession dbSession, String groupName) {
@@ -53,6 +67,49 @@ public class GroupService {
     return Optional.ofNullable(dbClient.groupDao().selectByUuid(dbSession, groupUuid));
   }
 
+  public SearchResults<GroupInformation> search(DbSession dbSession, GroupSearchRequest groupSearchRequest) {
+    GroupDto defaultGroup = defaultGroupFinder.findDefaultGroup(dbSession);
+    GroupQuery query = toGroupQuery(groupSearchRequest);
+
+    List<GroupDto> groups = dbClient.groupDao().selectByQuery(dbSession, query, groupSearchRequest.page(), groupSearchRequest.pageSize());
+    List<String> groupUuids = extractGroupUuids(groups);
+    Map<String, Boolean> groupUuidToIsManaged = managedInstanceService.getGroupUuidToManaged(dbSession, new HashSet<>(groupUuids));
+
+    List<GroupInformation> results = groups.stream()
+      .map(groupDto -> toGroupInformation(groupDto, defaultGroup.getUuid(), groupUuidToIsManaged))
+      .toList();
+
+    int limit = dbClient.groupDao().countByQuery(dbSession, query);
+    return new SearchResults<>(results, limit);
+  }
+
+  private GroupQuery toGroupQuery(GroupSearchRequest groupSearchRequest) {
+    return GroupQuery.builder()
+      .searchText(groupSearchRequest.query())
+      .isManagedClause(getManagedInstanceSql(groupSearchRequest.managed()))
+      .build();
+  }
+
+  @CheckForNull
+  private String getManagedInstanceSql(@Nullable Boolean isManaged) {
+    if (managedInstanceService.isInstanceExternallyManaged()) {
+      return Optional.ofNullable(isManaged)
+        .map(managedInstanceService::getManagedGroupsSqlFilter)
+        .orElse(null);
+    } else if (TRUE.equals(isManaged)) {
+      throw BadRequestException.create("The 'managed' parameter is only available for managed instances.");
+    }
+    return null;
+  }
+
+  private static List<String> extractGroupUuids(List<GroupDto> groups) {
+    return groups.stream().map(GroupDto::getUuid).toList();
+  }
+
+  private static GroupInformation toGroupInformation(GroupDto groupDto, String defaultGroupUuid, Map<String, Boolean> groupUuidToIsManaged) {
+    return new GroupInformation(groupDto, groupUuidToIsManaged.getOrDefault(groupDto.getUuid(), false), defaultGroupUuid.equals(groupDto.getUuid()));
+  }
+
   public void delete(DbSession dbSession, GroupDto group) {
     checkGroupIsNotDefault(dbSession, group);
     checkNotTryingToDeleteLastAdminGroup(dbSession, group);
@@ -168,6 +225,7 @@ public class GroupService {
   private void removeExternalGroupMapping(DbSession dbSession, GroupDto group) {
     dbClient.externalGroupDao().deleteByGroupUuid(dbSession, group.getUuid());
   }
+
   private void removeGithubOrganizationGroup(DbSession dbSession, GroupDto group) {
     dbClient.githubOrganizationGroupDao().deleteByGroupUuid(dbSession, group.getUuid());
   }
diff --git a/server/sonar-webserver-common/src/test/java/org/sonar/server/common/group/service/GroupServiceTest.java b/server/sonar-webserver-common/src/test/java/org/sonar/server/common/group/service/GroupServiceTest.java
index f64f4e1c200..06262b4456e 100644
--- a/server/sonar-webserver-common/src/test/java/org/sonar/server/common/group/service/GroupServiceTest.java
+++ b/server/sonar-webserver-common/src/test/java/org/sonar/server/common/group/service/GroupServiceTest.java
@@ -22,12 +22,16 @@ package org.sonar.server.common.group.service;
 import com.tngtech.java.junit.dataprovider.DataProvider;
 import com.tngtech.java.junit.dataprovider.DataProviderRunner;
 import com.tngtech.java.junit.dataprovider.UseDataProvider;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
@@ -46,16 +50,23 @@ import org.sonar.db.scim.ScimGroupDao;
 import org.sonar.db.user.ExternalGroupDao;
 import org.sonar.db.user.GroupDao;
 import org.sonar.db.user.GroupDto;
+import org.sonar.db.user.GroupQuery;
 import org.sonar.db.user.RoleDao;
 import org.sonar.db.user.UserGroupDao;
+import org.sonar.server.common.SearchResults;
 import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.management.ManagedInstanceService;
+import org.sonar.server.usergroups.DefaultGroupFinder;
 
 import static java.lang.String.format;
+import static java.util.function.Function.identity;
 import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -75,9 +86,16 @@ public class GroupServiceTest {
   private DbClient dbClient;
   @Mock
   private UuidFactory uuidFactory;
+  @Mock
+  private DefaultGroupFinder defaultGroupFinder;
+  @Mock
+  private ManagedInstanceService managedInstanceService;
   @InjectMocks
   private GroupService groupService;
 
+  @Captor
+  private ArgumentCaptor<GroupQuery> queryCaptor;
+
   @Rule
   public MockitoRule rule = MockitoJUnit.rule();
 
@@ -317,6 +335,76 @@ public class GroupServiceTest {
     };
   }
 
+  @Test
+  public void search_whenSeveralGroupFound_returnsThem() {
+    GroupDto groupDto1 = mockGroupDto("1");
+    GroupDto groupDto2 = mockGroupDto("2");
+    GroupDto defaultGroup = mockDefaultGroup();
+
+    when(dbClient.groupDao().selectByQuery(eq(dbSession), queryCaptor.capture(), eq(5), eq(24)))
+      .thenReturn(List.of(groupDto1, groupDto2, defaultGroup));
+
+    Map<String, Boolean> groupUuidToManaged = Map.of(
+      groupDto1.getUuid(), false,
+      groupDto2.getUuid(), true,
+      defaultGroup.getUuid(), false
+    );
+    when(managedInstanceService.getGroupUuidToManaged(dbSession, groupUuidToManaged.keySet())).thenReturn(groupUuidToManaged);
+
+    when(dbClient.groupDao().countByQuery(eq(dbSession), any())).thenReturn(300);
+
+    SearchResults<GroupInformation> searchResults = groupService.search(dbSession, new GroupSearchRequest("query", null, 5, 24));
+    assertThat(searchResults.total()).isEqualTo(300);
+
+    Map<String, GroupInformation> uuidToGroupInformation = searchResults.searchResults().stream()
+      .collect(Collectors.toMap(groupInformation -> groupInformation.groupDto().getUuid(), identity()));
+    assertGroupInformation(uuidToGroupInformation, groupDto1, false, false);
+    assertGroupInformation(uuidToGroupInformation, groupDto2, true, false);
+    assertGroupInformation(uuidToGroupInformation, defaultGroup, false, true);
+
+    assertThat(queryCaptor.getValue().getSearchText()).isEqualTo("%QUERY%");
+    assertThat(queryCaptor.getValue().getIsManagedSqlClause()).isNull();
+  }
+
+  @Test
+  public void search_whenInstanceManagedAndManagedIsTrue_addsManagedClause() {
+    mockManagedInstance();
+    when(dbClient.groupDao().selectByQuery(eq(dbSession), queryCaptor.capture(), anyInt(), anyInt())).thenReturn(List.of());
+
+    groupService.search(dbSession, new GroupSearchRequest("query", true, 5, 24));
+
+    assertThat(queryCaptor.getValue().getIsManagedSqlClause()).isEqualTo("managed_filter");
+  }
+
+  @Test
+  public void search_whenInstanceManagedAndManagedIsFalse_addsManagedClause() {
+    mockManagedInstance();
+    when(dbClient.groupDao().selectByQuery(eq(dbSession), queryCaptor.capture(), anyInt(), anyInt())).thenReturn(List.of());
+
+    groupService.search(dbSession, new GroupSearchRequest("query", false, 5, 24));
+
+    assertThat(queryCaptor.getValue().getIsManagedSqlClause()).isEqualTo("not_managed_filter");
+  }
+
+  @Test
+  public void search_whenInstanceNotManagedAndManagedIsTrue_throws() {
+    assertThatExceptionOfType(BadRequestException.class)
+      .isThrownBy(() -> groupService.search(dbSession, new GroupSearchRequest("query", true, 5, 24)))
+      .withMessage("The 'managed' parameter is only available for managed instances.");
+  }
+
+  private void mockManagedInstance() {
+    when(managedInstanceService.isInstanceExternallyManaged()).thenReturn(true);
+    when(managedInstanceService.getManagedGroupsSqlFilter(true)).thenReturn("managed_filter");
+    when(managedInstanceService.getManagedGroupsSqlFilter(false)).thenReturn("not_managed_filter");
+  }
+
+  private static void assertGroupInformation(Map<String, GroupInformation> uuidToGroupInformation, GroupDto expectedGroupDto, boolean expectedManaged, boolean expectedDefault) {
+    assertThat(uuidToGroupInformation.get(expectedGroupDto.getUuid()).groupDto()).isEqualTo(expectedGroupDto);
+    assertThat(uuidToGroupInformation.get(expectedGroupDto.getUuid()).isManaged()).isEqualTo(expectedManaged);
+    assertThat(uuidToGroupInformation.get(expectedGroupDto.getUuid()).isDefault()).isEqualTo(expectedDefault);
+  }
+
   private static GroupDto mockGroupDto() {
     GroupDto groupDto = mock(GroupDto.class);
     when(groupDto.getName()).thenReturn(GROUP_NAME);
@@ -324,11 +412,19 @@ public class GroupServiceTest {
     return groupDto;
   }
 
+  private static GroupDto mockGroupDto(String id) {
+    GroupDto groupDto = mock(GroupDto.class);
+    when(groupDto.getUuid()).thenReturn(id);
+    when(groupDto.getName()).thenReturn("name_" + id);
+    return groupDto;
+  }
+
   private GroupDto mockDefaultGroup() {
     GroupDto defaultGroup = mock(GroupDto.class);
     when(defaultGroup.getName()).thenReturn(DEFAULT_GROUP_NAME);
     when(defaultGroup.getUuid()).thenReturn(DEFAULT_GROUP_UUID);
     when(dbClient.groupDao().selectByName(dbSession, DEFAULT_GROUP_NAME)).thenReturn(Optional.of(defaultGroup));
+    when(defaultGroupFinder.findDefaultGroup(dbSession)).thenReturn(defaultGroup);
     return defaultGroup;
   }
 
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/DefaultGroupController.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/DefaultGroupController.java
index 72bf4421c6d..89cb65e8e04 100644
--- a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/DefaultGroupController.java
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/DefaultGroupController.java
@@ -19,15 +19,23 @@
  */
 package org.sonar.server.v2.api.group.controller;
 
+import java.util.List;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.user.GroupDto;
+import org.sonar.server.common.SearchResults;
+import org.sonar.server.common.group.service.GroupInformation;
+import org.sonar.server.common.group.service.GroupSearchRequest;
 import org.sonar.server.common.group.service.GroupService;
 import org.sonar.server.common.management.ManagedInstanceChecker;
 import org.sonar.server.exceptions.NotFoundException;
 import org.sonar.server.user.UserSession;
 import org.sonar.server.v2.api.group.request.GroupUpdateRestRequest;
+import org.sonar.server.v2.api.group.request.GroupsSearchRestRequest;
+import org.sonar.server.v2.api.group.response.GroupsSearchRestResponse;
 import org.sonar.server.v2.api.group.response.RestGroupResponse;
+import org.sonar.server.v2.api.model.RestPage;
+import org.sonar.server.v2.api.response.PageRestResponse;
 
 public class DefaultGroupController implements GroupController {
 
@@ -45,6 +53,23 @@ public class DefaultGroupController implements GroupController {
   }
 
   @Override
+  public GroupsSearchRestResponse search(GroupsSearchRestRequest groupsSearchRestRequest, RestPage restPage) {
+    userSession.checkLoggedIn().checkIsSystemAdministrator();
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      GroupSearchRequest groupSearchRequest = new GroupSearchRequest(groupsSearchRestRequest.q(), groupsSearchRestRequest.managed(), restPage.pageIndex(), restPage.pageSize());
+      SearchResults<GroupInformation> searchResults = groupService.search(dbSession, groupSearchRequest);
+      List<RestGroupResponse> restGroupResponses = toRestGroupResponses(searchResults);
+      return new GroupsSearchRestResponse(restGroupResponses, new PageRestResponse(restPage.pageIndex(), restPage.pageSize(), searchResults.total()));
+    }
+  }
+
+  private static List<RestGroupResponse> toRestGroupResponses(SearchResults<GroupInformation> searchResults) {
+    return searchResults.searchResults().stream()
+      .map(groupInformation -> toRestGroup(groupInformation.groupDto()))
+      .toList();
+  }
+
+  @Override
   public RestGroupResponse fetchGroup(String id) {
     userSession.checkLoggedIn().checkIsSystemAdministrator();
     try (DbSession session = dbClient.openSession(false)) {
@@ -89,7 +114,7 @@ public class DefaultGroupController implements GroupController {
       .orElseThrow(() -> new NotFoundException(String.format(GROUP_NOT_FOUND_MESSAGE, id)));
   }
 
-  private static RestGroupResponse toRestGroup(GroupDto updatedGroup) {
-    return new RestGroupResponse(updatedGroup.getUuid(), updatedGroup.getName(), updatedGroup.getDescription());
+  private static RestGroupResponse toRestGroup(GroupDto groupDto) {
+    return new RestGroupResponse(groupDto.getUuid(), groupDto.getName(), groupDto.getDescription());
   }
 }
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/GroupController.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/GroupController.java
index dac00c961c3..0d9cc3607fe 100644
--- a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/GroupController.java
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/controller/GroupController.java
@@ -24,7 +24,11 @@ import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.enums.ParameterIn;
 import javax.validation.Valid;
 import org.sonar.server.v2.api.group.request.GroupUpdateRestRequest;
+import org.sonar.server.v2.api.group.request.GroupsSearchRestRequest;
+import org.sonar.server.v2.api.group.response.GroupsSearchRestResponse;
 import org.sonar.server.v2.api.group.response.RestGroupResponse;
+import org.sonar.server.v2.api.model.RestPage;
+import org.springdoc.api.annotations.ParameterObject;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.DeleteMapping;
@@ -43,6 +47,16 @@ import static org.sonar.server.v2.WebApiEndpoints.JSON_MERGE_PATCH_CONTENT_TYPE;
 @RestController
 public interface GroupController {
 
+  @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
+  @ResponseStatus(HttpStatus.OK)
+  @Operation(summary = "Group search", description = """
+      Get the list of groups.
+      The results are sorted alphabetically by group name.
+    """)
+  GroupsSearchRestResponse search(
+    @Valid @ParameterObject GroupsSearchRestRequest groupsSearchRestRequest,
+    @Valid @ParameterObject RestPage restPage);
+
   @GetMapping(path = "/{id}")
   @ResponseStatus(HttpStatus.OK)
   @Operation(summary = "Fetch a single group", description = "Fetch a single group.")
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/request/GroupsSearchRestRequest.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/request/GroupsSearchRestRequest.java
new file mode 100644
index 00000000000..359041e6f32
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/request/GroupsSearchRestRequest.java
@@ -0,0 +1,37 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.group.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import javax.annotation.Nullable;
+
+public record GroupsSearchRestRequest(
+  @Nullable
+  @Schema(description = "Return managed or non-managed groups. Only available for managed instances, throws for non-managed instances")
+  Boolean managed,
+
+  @Nullable
+  @Schema(description = "Filter on name.\n"
+                        + "This parameter can either perform an exact match, or a partial match (contains), it is case insensitive.")
+  String q
+
+) {
+
+}
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/response/GroupsSearchRestResponse.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/response/GroupsSearchRestResponse.java
new file mode 100644
index 00000000000..1d72430e4a7
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/group/response/GroupsSearchRestResponse.java
@@ -0,0 +1,26 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.group.response;
+
+import java.util.List;
+import org.sonar.server.v2.api.response.PageRestResponse;
+
+public record GroupsSearchRestResponse(List<RestGroupResponse> groups, PageRestResponse page) {
+}
diff --git a/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/group/controller/DefaultGroupControllerTest.java b/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/group/controller/DefaultGroupControllerTest.java
index 743a902107e..e2d325e5e0b 100644
--- a/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/group/controller/DefaultGroupControllerTest.java
+++ b/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/group/controller/DefaultGroupControllerTest.java
@@ -21,31 +21,45 @@ package org.sonar.server.v2.api.group.controller;
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import javax.annotation.Nullable;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.user.GroupDto;
+import org.sonar.server.common.SearchResults;
+import org.sonar.server.common.group.service.GroupInformation;
+import org.sonar.server.common.group.service.GroupSearchRequest;
 import org.sonar.server.common.group.service.GroupService;
 import org.sonar.server.common.management.ManagedInstanceChecker;
 import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.tester.UserSessionRule;
 import org.sonar.server.v2.api.ControllerTester;
+import org.sonar.server.v2.api.group.response.GroupsSearchRestResponse;
 import org.sonar.server.v2.api.group.response.RestGroupResponse;
 import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.test.web.servlet.MvcResult;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 import static org.sonar.server.v2.WebApiEndpoints.GROUPS_ENDPOINT;
 import static org.sonar.server.v2.WebApiEndpoints.JSON_MERGE_PATCH_CONTENT_TYPE;
+import static org.sonar.server.v2.api.model.RestPage.DEFAULT_PAGE_INDEX;
+import static org.sonar.server.v2.api.model.RestPage.DEFAULT_PAGE_SIZE;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch;
@@ -235,4 +249,94 @@ public class DefaultGroupControllerTest {
     assertThat(restGroupResponse.description()).isEqualTo(newDescription);
   }
 
+  @Test
+  public void search_whenCallerIsNotAdmin_shouldReturnForbidden() throws Exception {
+    userSession.logIn().setNonSystemAdministrator();
+    mockMvc.perform(
+        get(GROUPS_ENDPOINT + "/" + GROUP_UUID)
+      )
+      .andExpectAll(
+        status().isForbidden(),
+        content().json("{\"message\":\"Insufficient privileges\"}"));
+  }
+
+  @Test
+  public void search_whenNoParameters_shouldUseDefaultAndForwardToUserService() throws Exception {
+    userSession.logIn().setSystemAdministrator();
+    when(groupService.search(eq(dbSession), any())).thenReturn(new SearchResults<>(List.of(), 0));
+
+    mockMvc.perform(get(GROUPS_ENDPOINT)).andExpect(status().isOk());
+
+    ArgumentCaptor<GroupSearchRequest> requestCaptor = ArgumentCaptor.forClass(GroupSearchRequest.class);
+    verify(groupService).search(eq(dbSession), requestCaptor.capture());
+    assertThat(requestCaptor.getValue().pageSize()).hasToString(DEFAULT_PAGE_SIZE);
+    assertThat(requestCaptor.getValue().page()).hasToString(DEFAULT_PAGE_INDEX);
+    assertThat(requestCaptor.getValue().managed()).isNull();
+    assertThat(requestCaptor.getValue().query()).isNull();
+  }
+
+  @Test
+  public void search_whenParametersUsed_shouldForwardWithParameters() throws Exception {
+    userSession.logIn().setSystemAdministrator();
+    when(groupService.search(eq(dbSession), any())).thenReturn(new SearchResults<>(List.of(), 0));
+
+    mockMvc.perform(get(GROUPS_ENDPOINT)
+        .param("managed", "true")
+        .param("q", "q")
+        .param("pageSize", "100")
+        .param("pageIndex", "2"))
+      .andExpect(status().isOk());
+
+    ArgumentCaptor<GroupSearchRequest> requestCaptor = ArgumentCaptor.forClass(GroupSearchRequest.class);
+    verify(groupService).search(eq(dbSession), requestCaptor.capture());
+    assertThat(requestCaptor.getValue().pageSize()).isEqualTo(100);
+    assertThat(requestCaptor.getValue().page()).isEqualTo(2);
+    assertThat(requestCaptor.getValue().managed()).isTrue();
+    assertThat(requestCaptor.getValue().query()).isEqualTo("q");
+  }
+
+  @Test
+  public void search_whenGroupServiceReturnUsers_shouldReturnThem() throws Exception {
+    userSession.logIn().setSystemAdministrator();
+
+    GroupInformation group1 = generateGroupSearchResult("group1", true, true);
+    GroupInformation group2 = generateGroupSearchResult("user2", false, false);
+    GroupInformation group3 = generateGroupSearchResult("user3", true, false);
+    List<GroupInformation> groups = List.of(group1, group2, group3);
+    SearchResults<GroupInformation> searchResult = new SearchResults<>(groups, groups.size());
+    when(groupService.search(eq(dbSession), any())).thenReturn(searchResult);
+
+    MvcResult mvcResult = mockMvc.perform(get(GROUPS_ENDPOINT))
+      .andExpect(status().isOk())
+      .andReturn();
+
+    GroupsSearchRestResponse actualGroupsSearchRestResponse = GSON.fromJson(mvcResult.getResponse().getContentAsString(), GroupsSearchRestResponse.class);
+    Map<String, RestGroupResponse> groupIdToGroupResponse = actualGroupsSearchRestResponse.groups().stream()
+      .collect(Collectors.toMap(RestGroupResponse::id, Function.identity()));
+
+    assertResponseContains(groupIdToGroupResponse, group1);
+    assertResponseContains(groupIdToGroupResponse, group2);
+    assertResponseContains(groupIdToGroupResponse, group3);
+
+    assertThat(actualGroupsSearchRestResponse.page().pageIndex()).hasToString(DEFAULT_PAGE_INDEX);
+    assertThat(actualGroupsSearchRestResponse.page().pageSize()).hasToString(DEFAULT_PAGE_SIZE);
+    assertThat(actualGroupsSearchRestResponse.page().total()).isEqualTo(groups.size());
+
+  }
+
+  private void assertResponseContains(Map<String, RestGroupResponse> groupIdToGroupResponse, GroupInformation expectedGroup) {
+    RestGroupResponse restGroup = groupIdToGroupResponse.get(expectedGroup.groupDto().getUuid());
+    assertThat(restGroup).isNotNull();
+    assertThat(restGroup.name()).isEqualTo(expectedGroup.groupDto().getName());
+    assertThat(restGroup.description()).isEqualTo(expectedGroup.groupDto().getDescription());
+    //TODO add assertions for managed & default flag
+  }
+
+  private GroupInformation generateGroupSearchResult(String id, boolean managed, boolean isDefault) {
+    GroupDto groupDto = new GroupDto()
+      .setUuid(id)
+      .setName("name_"+id)
+      .setDescription("description_"+id);
+    return new GroupInformation(groupDto, managed, isDefault);
+  }
 }
diff --git a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/CreateActionIT.java b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/CreateActionIT.java
index 225e2478031..2e3606f3ca4 100644
--- a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/CreateActionIT.java
+++ b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/CreateActionIT.java
@@ -29,11 +29,13 @@ import org.sonar.core.util.SequenceUuidFactory;
 import org.sonar.db.DbTester;
 import org.sonar.db.user.GroupDto;
 import org.sonar.server.common.group.service.GroupService;
+import org.sonar.server.common.management.ManagedInstanceChecker;
 import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.exceptions.ForbiddenException;
 import org.sonar.server.exceptions.ServerException;
-import org.sonar.server.common.management.ManagedInstanceChecker;
+import org.sonar.server.management.ManagedInstanceService;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.usergroups.DefaultGroupFinder;
 import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.WsActionTester;
 
@@ -51,7 +53,10 @@ public class CreateActionIT {
   public UserSessionRule userSession = UserSessionRule.standalone();
   private ManagedInstanceChecker managedInstanceChecker = mock(ManagedInstanceChecker.class);
 
-  private final CreateAction underTest = new CreateAction(db.getDbClient(), userSession, newGroupService(), managedInstanceChecker);
+  private final ManagedInstanceService managedInstanceService = mock();
+  private final DefaultGroupFinder defaultGroupFinder = new DefaultGroupFinder(db.getDbClient());
+  private final GroupService groupService = new GroupService(db.getDbClient(), new SequenceUuidFactory(), defaultGroupFinder, managedInstanceService);
+  private final CreateAction underTest = new CreateAction(db.getDbClient(), userSession, groupService, managedInstanceChecker);
   private final WsActionTester tester = new WsActionTester(underTest);
 
   @Test
@@ -75,12 +80,12 @@ public class CreateActionIT {
       .setParam("description", "Business Unit for Some Awesome Product")
       .execute()
       .assertJson("{" +
-        "  \"group\": {" +
-        "    \"name\": \"some-product-bu\"," +
-        "    \"description\": \"Business Unit for Some Awesome Product\"," +
-        "    \"membersCount\": 0" +
-        "  }" +
-        "}");
+                  "  \"group\": {" +
+                  "    \"name\": \"some-product-bu\"," +
+                  "    \"description\": \"Business Unit for Some Awesome Product\"," +
+                  "    \"membersCount\": 0" +
+                  "  }" +
+                  "}");
 
     assertThat(db.users().selectGroup("some-product-bu")).isPresent();
   }
@@ -94,13 +99,13 @@ public class CreateActionIT {
       .setParam("description", "Business Unit for Some Awesome Product")
       .execute()
       .assertJson("{" +
-        "  \"group\": {" +
-        "    \"name\": \"some-product-bu\"," +
-        "    \"description\": \"Business Unit for Some Awesome Product\"," +
-        "    \"membersCount\": 0," +
-        "    \"default\": false" +
-        "  }" +
-        "}");
+                  "  \"group\": {" +
+                  "    \"name\": \"some-product-bu\"," +
+                  "    \"description\": \"Business Unit for Some Awesome Product\"," +
+                  "    \"membersCount\": 0," +
+                  "    \"default\": false" +
+                  "  }" +
+                  "}");
   }
 
   @Test
@@ -193,7 +198,4 @@ public class CreateActionIT {
     userSession.logIn().addPermission(ADMINISTER);
   }
 
-  private GroupService newGroupService() {
-    return new GroupService(db.getDbClient(), new SequenceUuidFactory());
-  }
 }
diff --git a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/DeleteActionIT.java b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/DeleteActionIT.java
index f8d2e2eee36..710769f4286 100644
--- a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/DeleteActionIT.java
+++ b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/DeleteActionIT.java
@@ -42,6 +42,7 @@ import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.exceptions.NotFoundException;
 import org.sonar.server.management.ManagedInstanceService;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.usergroups.DefaultGroupFinder;
 import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.TestResponse;
 import org.sonar.server.ws.WsActionTester;
@@ -63,9 +64,10 @@ public class DeleteActionIT {
   public UserSessionRule userSession = UserSessionRule.standalone();
   @Rule
   public DbTester db = DbTester.create(new AlwaysIncreasingSystem2());
-  private final GroupService groupService = new GroupService(db.getDbClient(), UuidFactoryImpl.INSTANCE);
 
-  private final ManagedInstanceService managedInstanceService = mock(ManagedInstanceService.class);
+  private final ManagedInstanceService managedInstanceService = mock();
+  private final DefaultGroupFinder defaultGroupFinder = new DefaultGroupFinder(db.getDbClient());
+  private final GroupService groupService = new GroupService(db.getDbClient(), UuidFactoryImpl.INSTANCE, defaultGroupFinder, managedInstanceService);
   private final WsActionTester ws = new WsActionTester(new DeleteAction(db.getDbClient(), userSession, groupService, managedInstanceService));
 
   @Test
diff --git a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/ExternalGroupServiceIT.java b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/ExternalGroupServiceIT.java
index b9666421dbf..614acbe73e5 100644
--- a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/ExternalGroupServiceIT.java
+++ b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/ExternalGroupServiceIT.java
@@ -30,8 +30,11 @@ import org.sonar.db.DbTester;
 import org.sonar.db.user.ExternalGroupDto;
 import org.sonar.db.user.GroupDto;
 import org.sonar.server.common.group.service.GroupService;
+import org.sonar.server.management.ManagedInstanceService;
+import org.sonar.server.usergroups.DefaultGroupFinder;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 public class ExternalGroupServiceIT {
 
@@ -43,7 +46,11 @@ public class ExternalGroupServiceIT {
   public DbTester dbTester = DbTester.create(System2.INSTANCE);
   private final DbClient dbClient = dbTester.getDbClient();
   private final DbSession dbSession = dbTester.getSession();
-  private final GroupService groupService = new GroupService(dbClient, UuidFactoryFast.getInstance());
+
+  private final DefaultGroupFinder defaultGroupFinder = new DefaultGroupFinder(dbClient);
+
+  private final ManagedInstanceService managedInstanceService = mock();
+  private final GroupService groupService = new GroupService(dbClient, UuidFactoryFast.getInstance(), defaultGroupFinder, managedInstanceService);
 
   private final ExternalGroupService externalGroupService = new ExternalGroupService(dbClient, groupService);
 
diff --git a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/SearchActionIT.java b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/SearchActionIT.java
index c8951c475cb..9814dc01ce9 100644
--- a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/SearchActionIT.java
+++ b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/SearchActionIT.java
@@ -25,12 +25,14 @@ import org.junit.Test;
 import org.sonar.api.server.ws.Change;
 import org.sonar.api.server.ws.WebService;
 import org.sonar.api.utils.System2;
+import org.sonar.core.util.SequenceUuidFactory;
 import org.sonar.core.util.UuidFactory;
 import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
 import org.sonar.db.scim.ScimGroupDao;
 import org.sonar.db.user.GroupDto;
 import org.sonar.db.user.UserDto;
+import org.sonar.server.common.group.service.GroupService;
 import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.exceptions.UnauthorizedException;
 import org.sonar.server.management.ManagedInstanceService;
@@ -56,7 +58,6 @@ import static org.sonar.api.server.ws.WebService.Param.FIELDS;
 import static org.sonar.api.server.ws.WebService.Param.PAGE;
 import static org.sonar.api.server.ws.WebService.Param.PAGE_SIZE;
 import static org.sonar.api.server.ws.WebService.Param.TEXT_QUERY;
-import static org.sonar.db.permission.GlobalPermission.ADMINISTER;
 import static org.sonar.db.user.GroupTesting.newGroupDto;
 import static org.sonar.test.JsonAssert.assertJson;
 import static org.sonarqube.ws.UserGroups.Group;
@@ -72,8 +73,9 @@ public class SearchActionIT {
 
   private final ManagedInstanceService managedInstanceService = mock(ManagedInstanceService.class);
 
-  private final WsActionTester ws = new WsActionTester(new SearchAction(db.getDbClient(), userSession,
-    new DefaultGroupFinder(db.getDbClient()), managedInstanceService));
+  private final GroupService groupService = new GroupService(db.getDbClient(), new SequenceUuidFactory(), new DefaultGroupFinder(db.getDbClient()), managedInstanceService);
+
+  private final WsActionTester ws = new WsActionTester(new SearchAction(db.getDbClient(), userSession, groupService));
 
   @Test
   public void define_search_action() {
@@ -187,6 +189,7 @@ public class SearchActionIT {
 
   @Test
   public void search_whenFilteringByManagedAndInstanceNotManaged_throws() {
+    insertDefaultGroup(1);
     userSession.logIn().setSystemAdministrator();
 
     TestRequest testRequest = ws.newRequest()
@@ -372,6 +375,6 @@ public class SearchActionIT {
   }
 
   private void loginAsAdmin() {
-    userSession.logIn("user").addPermission(ADMINISTER);
+    userSession.logIn("user").setSystemAdministrator();
   }
 }
diff --git a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/UpdateActionIT.java b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/UpdateActionIT.java
index f82cbaee955..0b32305bc5f 100644
--- a/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/UpdateActionIT.java
+++ b/server/sonar-webserver-webapi/src/it/java/org/sonar/server/usergroups/ws/UpdateActionIT.java
@@ -29,12 +29,14 @@ import org.sonar.db.DbTester;
 import org.sonar.db.user.GroupDto;
 import org.sonar.db.user.UserDto;
 import org.sonar.server.common.group.service.GroupService;
+import org.sonar.server.common.management.ManagedInstanceChecker;
 import org.sonar.server.exceptions.BadRequestException;
 import org.sonar.server.exceptions.ForbiddenException;
 import org.sonar.server.exceptions.NotFoundException;
 import org.sonar.server.exceptions.ServerException;
-import org.sonar.server.common.management.ManagedInstanceChecker;
+import org.sonar.server.management.ManagedInstanceService;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.usergroups.DefaultGroupFinder;
 import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.WsActionTester;
 
@@ -56,9 +58,11 @@ public class UpdateActionIT {
   public UserSessionRule userSession = UserSessionRule.standalone();
 
   private ManagedInstanceChecker managedInstanceChecker = mock(ManagedInstanceChecker.class);
+  private final DefaultGroupFinder defaultGroupFinder = new DefaultGroupFinder(db.getDbClient());
 
+  private final ManagedInstanceService managedInstanceService = mock();
   private final WsActionTester ws = new WsActionTester(
-    new UpdateAction(db.getDbClient(), userSession, new GroupService(db.getDbClient(), UuidFactoryImpl.INSTANCE), managedInstanceChecker));
+    new UpdateAction(db.getDbClient(), userSession, new GroupService(db.getDbClient(), UuidFactoryImpl.INSTANCE, defaultGroupFinder, managedInstanceService), managedInstanceChecker));
 
   @Test
   public void verify_definition() {
diff --git a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/usergroups/ws/SearchAction.java b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/usergroups/ws/SearchAction.java
index 3646176ea97..8b6e5226b1d 100644
--- a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/usergroups/ws/SearchAction.java
+++ b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/usergroups/ws/SearchAction.java
@@ -23,9 +23,8 @@ import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
-import org.jetbrains.annotations.Nullable;
+import java.util.stream.Collectors;
 import org.sonar.api.server.ws.Change;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.Response;
@@ -36,16 +35,15 @@ import org.sonar.api.utils.Paging;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.user.GroupDto;
-import org.sonar.db.user.GroupQuery;
-import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.management.ManagedInstanceService;
+import org.sonar.server.common.SearchResults;
+import org.sonar.server.common.group.service.GroupInformation;
+import org.sonar.server.common.group.service.GroupSearchRequest;
+import org.sonar.server.common.group.service.GroupService;
 import org.sonar.server.user.UserSession;
-import org.sonar.server.usergroups.DefaultGroupFinder;
 
 import static java.lang.Boolean.TRUE;
 import static java.util.Optional.ofNullable;
 import static org.sonar.api.utils.Paging.forPageIndex;
-import static org.sonar.db.permission.GlobalPermission.ADMINISTER;
 import static org.sonar.server.es.SearchOptions.MAX_PAGE_SIZE;
 import static org.sonar.server.ws.WsUtils.writeProtobuf;
 import static org.sonarqube.ws.UserGroups.Group;
@@ -62,14 +60,13 @@ public class SearchAction implements UserGroupsWsAction {
 
   private final DbClient dbClient;
   private final UserSession userSession;
-  private final DefaultGroupFinder defaultGroupFinder;
-  private final ManagedInstanceService managedInstanceService;
 
-  public SearchAction(DbClient dbClient, UserSession userSession, DefaultGroupFinder defaultGroupFinder, ManagedInstanceService managedInstanceService) {
+  private final GroupService groupService;
+
+  public SearchAction(DbClient dbClient, UserSession userSession, GroupService groupService) {
     this.dbClient = dbClient;
     this.userSession = userSession;
-    this.defaultGroupFinder = defaultGroupFinder;
-    this.managedInstanceService = managedInstanceService;
+    this.groupService = groupService;
   }
 
   @Override
@@ -103,49 +100,26 @@ public class SearchAction implements UserGroupsWsAction {
     int page = request.mandatoryParamAsInt(Param.PAGE);
     int pageSize = request.mandatoryParamAsInt(Param.PAGE_SIZE);
 
-    GroupQuery query = buildGroupQuery(request);
     Set<String> fields = neededFields(request);
 
     try (DbSession dbSession = dbClient.openSession(false)) {
-      userSession.checkLoggedIn().checkPermission(ADMINISTER);
-      GroupDto defaultGroup = defaultGroupFinder.findDefaultGroup(dbSession);
-
-      int limit = dbClient.groupDao().countByQuery(dbSession, query);
-      List<GroupDto> groups = dbClient.groupDao().selectByQuery(dbSession, query, page, pageSize);
-      List<String> groupUuids = extractGroupUuids(groups);
-      Map<String, Boolean> groupUuidToIsManaged = managedInstanceService.getGroupUuidToManaged(dbSession, new HashSet<>(groupUuids));
-      Map<String, Integer> userCountByGroup = dbClient.groupMembershipDao().countUsersByGroups(dbSession, groupUuids);
-      Paging paging = forPageIndex(page).withPageSize(pageSize).andTotal(limit);
-      writeProtobuf(buildResponse(groups, userCountByGroup, groupUuidToIsManaged, fields, paging, defaultGroup), request, response);
-    }
-  }
+      userSession.checkLoggedIn().checkIsSystemAdministrator();
 
-  private GroupQuery buildGroupQuery(Request request) {
-    String textQuery = request.param(Param.TEXT_QUERY);
-    Boolean managed = request.paramAsBoolean(MANAGED_PARAM);
+      GroupSearchRequest groupSearchRequest = new GroupSearchRequest(request.param(Param.TEXT_QUERY), request.paramAsBoolean(MANAGED_PARAM), page, pageSize);
+      SearchResults<GroupInformation> searchResults = groupService.search(dbSession, groupSearchRequest);
 
-    GroupQuery.GroupQueryBuilder queryBuilder = GroupQuery.builder()
-      .searchText(textQuery);
+      Set<String> groupUuids = extractGroupUuids(searchResults.searchResults());
 
-    if (managedInstanceService.isInstanceExternallyManaged()) {
-      String managedInstanceSql = getManagedInstanceSql(managed);
-      queryBuilder.isManagedClause(managedInstanceSql);
-    } else if (TRUE.equals(managed)) {
-      throw BadRequestException.create("The 'managed' parameter is only available for managed instances.");
+      Map<String, Integer> userCountByGroup = dbClient.groupMembershipDao().countUsersByGroups(dbSession, groupUuids);
+      Paging paging = forPageIndex(page).withPageSize(pageSize).andTotal(searchResults.total());
+      writeProtobuf(buildResponse(searchResults.searchResults(), userCountByGroup, fields, paging), request, response);
     }
-    return queryBuilder.build();
-
-  }
-
-  @Nullable
-  private String getManagedInstanceSql(@Nullable Boolean managed) {
-    return Optional.ofNullable(managed)
-      .map(managedInstanceService::getManagedGroupsSqlFilter)
-      .orElse(null);
   }
 
-  private static List<String> extractGroupUuids(List<GroupDto> groups) {
-    return groups.stream().map(GroupDto::getUuid).toList();
+  private static Set<String> extractGroupUuids(List<GroupInformation> groupInformations) {
+    return groupInformations.stream()
+      .map(groupInformation -> groupInformation.groupDto().getUuid())
+      .collect(Collectors.toSet());
   }
 
   private static Set<String> neededFields(Request request) {
@@ -159,11 +133,11 @@ public class SearchAction implements UserGroupsWsAction {
     return fields;
   }
 
-  private static SearchWsResponse buildResponse(List<GroupDto> groups, Map<String, Integer> userCountByGroup,
-    Map<String, Boolean> groupUuidToIsManaged, Set<String> fields, Paging paging, GroupDto defaultGroup) {
+  private static SearchWsResponse buildResponse(List<GroupInformation> groups, Map<String, Integer> userCountByGroup,
+   Set<String> fields, Paging paging) {
     SearchWsResponse.Builder responseBuilder = SearchWsResponse.newBuilder();
     groups.forEach(group -> responseBuilder
-      .addGroups(toWsGroup(group, userCountByGroup.get(group.getName()), groupUuidToIsManaged.get(group.getUuid()), fields, defaultGroup.getUuid().equals(group.getUuid()))));
+      .addGroups(toWsGroup(group.groupDto(), userCountByGroup.get(group.groupDto().getName()), group.isManaged(), fields, group.isDefault())));
     responseBuilder.getPagingBuilder()
       .setPageIndex(paging.pageIndex())
       .setPageSize(paging.pageSize())