In Add users to group, only the first 10 can be viewed or selected

openbas-api/src/main/java/io/openbas/rest/asset_group/AssetGroupApi.java

@@ -11,6 +11,7 @@
 import io.openbas.rest.asset_group.form.AssetGroupInput;
 import io.openbas.rest.asset_group.form.AssetGroupOutput;
 import io.openbas.rest.asset_group.form.UpdateAssetsOnAssetGroupInput;
+import io.openbas.rest.helper.RestBehavior;
 import io.openbas.telemetry.Tracing;
 import io.openbas.utils.pagination.SearchPaginationInput;
 import jakarta.validation.Valid;
@@ -27,7 +28,7 @@
 @RestController
 @RequiredArgsConstructor
 @Secured(ROLE_USER)
-public class AssetGroupApi {
+public class AssetGroupApi extends RestBehavior {
 
   public static final String ASSET_GROUP_URI = "/api/asset_groups";
 

openbas-api/src/main/java/io/openbas/rest/user/UserApi.java

@@ -1,9 +1,9 @@
 package io.openbas.rest.user;
 
 import static io.openbas.database.model.User.ROLE_ADMIN;
+import static io.openbas.database.specification.UserSpecification.fromIds;
 import static io.openbas.helper.DatabaseHelper.updateRelation;
 import static io.openbas.helper.StreamHelper.iterableToSet;
-import static io.openbas.utils.pagination.PaginationUtils.buildPaginationJPA;
 
 import io.openbas.config.SessionManager;
 import io.openbas.database.model.User;
@@ -19,34 +19,40 @@
 import io.openbas.rest.user.form.user.ChangePasswordInput;
 import io.openbas.rest.user.form.user.CreateUserInput;
 import io.openbas.rest.user.form.user.UpdateUserInput;
+import io.openbas.rest.user.form.user.UserOutput;
+import io.openbas.rest.user.service.UserCriteriaBuilderService;
 import io.openbas.service.MailingService;
 import io.openbas.service.UserService;
+import io.openbas.telemetry.Tracing;
 import io.openbas.utils.pagination.SearchPaginationInput;
 import jakarta.annotation.Resource;
-import jakarta.transaction.Transactional;
 import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
 import java.util.List;
 import java.util.Optional;
 import org.apache.commons.collections4.map.PassiveExpiringMap;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.domain.Specification;
 import org.springframework.security.access.AccessDeniedException;
 import org.springframework.security.access.annotation.Secured;
 import org.springframework.security.authentication.BadCredentialsException;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.bind.annotation.*;
 
 @RestController
 public class UserApi extends RestBehavior {
+
+  public static final String USER_URI = "/api/users";
+
   PassiveExpiringMap<String, String> resetTokenMap = new PassiveExpiringMap<>(1000 * 60 * 10);
   @Resource private SessionManager sessionManager;
   private OrganizationRepository organizationRepository;
   private UserRepository userRepository;
   private TagRepository tagRepository;
   private UserService userService;
   private MailingService mailingService;
+  private UserCriteriaBuilderService userCriteriaBuilderService;
 
   @Autowired
   public void setMailingService(MailingService mailingService) {
@@ -73,6 +79,11 @@
     this.userRepository = userRepository;
   }
 
+  @Autowired
+  public void setUserCriteriaBuilderService(UserCriteriaBuilderService userCriteriaBuilderService) {
+    this.userCriteriaBuilderService = userCriteriaBuilderService;
+  }
+
   @PostMapping("/api/login")
   public User login(@Valid @RequestBody LoginUserInput input) {
     Optional<User> optionalUser = userRepository.findByEmailIgnoreCase(input.getLogin());
@@ -151,18 +162,22 @@
     return userRepository.rawAll();
   }
 
-  @PostMapping("/api/users/search")
-  public Page<User> users(@RequestBody @Valid final SearchPaginationInput searchPaginationInput) {
-    return buildPaginationJPA(
-        (Specification<User> specification, Pageable pageable) ->
-            this.userRepository.findAll(specification, pageable),
-        searchPaginationInput,
-        User.class);
+  @PostMapping(USER_URI + "/search")
+  public Page<UserOutput> users(
+      @RequestBody @Valid final SearchPaginationInput searchPaginationInput) {
+    return this.userCriteriaBuilderService.userPagination(searchPaginationInput);
+  }
+
+  @PostMapping(USER_URI + "/find")
+  @Transactional(readOnly = true)
+  @Tracing(name = "Find users", layer = "api", operation = "POST")
+  public List<UserOutput> findUsers(@RequestBody @Valid @NotNull final List<String> userIds) {
+    return this.userCriteriaBuilderService.find(fromIds(userIds));
   }
 
   @Secured(ROLE_ADMIN)
   @PutMapping("/api/users/{userId}/password")
-  @Transactional(rollbackOn = Exception.class)
+  @Transactional(rollbackFor = Exception.class)
   public User changePassword(
       @PathVariable String userId, @Valid @RequestBody ChangePasswordInput input) {
     User user = userRepository.findById(userId).orElseThrow(ElementNotFoundException::new);
@@ -172,14 +187,14 @@
 
   @Secured(ROLE_ADMIN)
   @PostMapping("/api/users")
-  @Transactional(rollbackOn = Exception.class)
+  @Transactional(rollbackFor = Exception.class)
   public User createUser(@Valid @RequestBody CreateUserInput input) {
     return userService.createUser(input, 1);
   }
 
   @Secured(ROLE_ADMIN)
   @PutMapping("/api/users/{userId}")
-  @Transactional(rollbackOn = Exception.class)
+  @Transactional(rollbackFor = Exception.class)
   public User updateUser(@PathVariable String userId, @Valid @RequestBody UpdateUserInput input) {
     User user = userRepository.findById(userId).orElseThrow(ElementNotFoundException::new);
     user.setUpdateAttributes(input);
@@ -193,7 +208,7 @@
 
   @Secured(ROLE_ADMIN)
   @DeleteMapping("/api/users/{userId}")
-  @Transactional(rollbackOn = Exception.class)
+  @Transactional(rollbackFor = Exception.class)
   public void deleteUser(@PathVariable String userId) {
     sessionManager.invalidateUserSession(userId);
     userRepository.deleteById(userId);

openbas-api/src/main/java/io/openbas/rest/user/form/user/UserOutput.java

@@ -0,0 +1,35 @@
+package io.openbas.rest.user.form.user;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import jakarta.validation.constraints.NotBlank;
+import java.util.Set;
+import lombok.Builder;
+import lombok.Data;
+
+@Builder
+@Data
+public class UserOutput {
+
+  @JsonProperty("user_id")
+  @NotBlank
+  private String id;
+
+  @JsonProperty("user_firstname")
+  private String firstname;
+
+  @JsonProperty("user_lastname")
+  private String lastname;
+
+  @JsonProperty("user_email")
+  @NotBlank
+  private String email;
+
+  @JsonProperty("user_admin")
+  private boolean admin;
+
+  @JsonProperty("user_organization_name")
+  private String organizationName;
+
+  @JsonProperty("user_tags")
+  private Set<String> tags;
+}

openbas-api/src/main/java/io/openbas/rest/user/helper/UserQueryHelper.java

@@ -0,0 +1,62 @@
+package io.openbas.rest.user.helper;
+
+import static io.openbas.utils.JpaUtils.createJoinArrayAggOnId;
+import static io.openbas.utils.JpaUtils.createLeftJoin;
+
+import io.openbas.database.model.Organization;
+import io.openbas.database.model.User;
+import io.openbas.rest.user.form.user.UserOutput;
+import jakarta.persistence.Tuple;
+import jakarta.persistence.TypedQuery;
+import jakarta.persistence.criteria.*;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class UserQueryHelper {
+
+  private UserQueryHelper() {}
+
+  // -- SELECT --
+
+  public static void select(CriteriaBuilder cb, CriteriaQuery<Tuple> cq, Root<User> userRoot) {
+    // Joins
+    Join<User, Organization> organizationJoin = createLeftJoin(userRoot, "organization");
+    // Array aggregations
+    Expression<String[]> tagIdsExpression = createJoinArrayAggOnId(cb, userRoot, "tags");
+
+    // Multiselect
+    cq.multiselect(
+            userRoot.get("id").alias("user_id"),
+            userRoot.get("firstname").alias("user_firstname"),
+            userRoot.get("lastname").alias("user_lastname"),
+            userRoot.get("email").alias("user_email"),
+            userRoot.get("admin").alias("user_admin"),
+            organizationJoin.get("name").alias("user_organization_name"),
+            tagIdsExpression.alias("user_tags"))
+        .distinct(true);
+
+    // Group by
+    cq.groupBy(userRoot.get("id"), organizationJoin.get("id"));
+  }
+
+  // -- EXECUTION --
+
+  public static List<UserOutput> execution(TypedQuery<Tuple> query) {
+    return query.getResultList().stream()
+        .map(
+            tuple ->
+                UserOutput.builder()
+                    .id(tuple.get("user_id", String.class))
+                    .firstname(tuple.get("user_firstname", String.class))
+                    .lastname(tuple.get("user_lastname", String.class))
+                    .email(tuple.get("user_email", String.class))
+                    .admin(tuple.get("user_admin", boolean.class))
+                    .organizationName(tuple.get("user_organization_name", String.class))
+                    .tags(
+                        Arrays.stream(tuple.get("user_tags", String[].class))
+                            .collect(Collectors.toSet()))
+                    .build())
+        .toList();
+  }
+}

openbas-api/src/main/java/io/openbas/rest/user/service/UserCriteriaBuilderService.java

@@ -0,0 +1,93 @@
+package io.openbas.rest.user.service;
+
+import static io.openbas.database.criteria.GenericCriteria.countQuery;
+import static io.openbas.rest.user.helper.UserQueryHelper.execution;
+import static io.openbas.rest.user.helper.UserQueryHelper.select;
+import static io.openbas.utils.pagination.PaginationUtils.buildPaginationCriteriaBuilder;
+import static io.openbas.utils.pagination.SortUtilsCriteriaBuilder.toSortCriteriaBuilder;
+
+import io.openbas.database.model.User;
+import io.openbas.rest.user.form.user.UserOutput;
+import io.openbas.utils.pagination.SearchPaginationInput;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+import jakarta.persistence.Tuple;
+import jakarta.persistence.TypedQuery;
+import jakarta.persistence.criteria.*;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Service;
+
+@RequiredArgsConstructor
+@Service
+public class UserCriteriaBuilderService {
+
+  @PersistenceContext private EntityManager entityManager;
+
+  public Page<UserOutput> userPagination(@NotNull SearchPaginationInput searchPaginationInput) {
+    return buildPaginationCriteriaBuilder(this::paginate, searchPaginationInput, User.class);
+  }
+
+  public List<UserOutput> find(Specification<User> specification) {
+    CriteriaBuilder cb = this.entityManager.getCriteriaBuilder();
+
+    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
+    Root<User> root = cq.from(User.class);
+    select(cb, cq, root);
+
+    if (specification != null) {
+      Predicate predicate = specification.toPredicate(root, cq, cb);
+      if (predicate != null) {
+        cq.where(predicate);
+      }
+    }
+
+    TypedQuery<Tuple> query = entityManager.createQuery(cq);
+    return execution(query);
+  }
+
+  // -- PRIVATE --
+
+  private Page<UserOutput> paginate(
+      Specification<User> specification,
+      Specification<User> specificationCount,
+      Pageable pageable) {
+    CriteriaBuilder cb = this.entityManager.getCriteriaBuilder();
+
+    CriteriaQuery<Tuple> cq = cb.createTupleQuery();
+    Root<User> userRoot = cq.from(User.class);
+    select(cb, cq, userRoot);
+
+    // -- Specification --
+    if (specification != null) {
+      Predicate predicate = specification.toPredicate(userRoot, cq, cb);
+      if (predicate != null) {
+        cq.where(predicate);
+      }
+    }
+
+    // -- Sorting --
+    List<Order> orders = toSortCriteriaBuilder(cb, userRoot, pageable.getSort());
+    cq.orderBy(orders);
+
+    // Type Query
+    TypedQuery<Tuple> query = entityManager.createQuery(cq);
+
+    // -- Pagination --
+    query.setFirstResult((int) pageable.getOffset());
+    query.setMaxResults(pageable.getPageSize());
+
+    // -- EXECUTION --
+    List<UserOutput> users = execution(query);
+
+    // -- Count Query --
+    Long total = countQuery(cb, this.entityManager, User.class, specificationCount);
+
+    return new PageImpl<>(users, pageable, total);
+  }
+}

openbas-front/src/actions/User.js

@@ -20,6 +20,12 @@ export const searchUsers = (paginationInput) => {
   return simplePostCall(uri, data);
 };
 
+export const findUsers = (userIds) => {
+  const data = userIds;
+  const uri = '/api/users/find';
+  return simplePostCall(uri, data);
+};
+
 export const addUser = data => dispatch => postReferential(schema.user, '/api/users', data)(dispatch);
 
 export const updateUserPassword = (userId, data) => dispatch => putReferential(schema.user, `/api/users/${userId}/password`, data)(dispatch);

openbas-front/src/admin/components/assets/asset_groups/AssetGroupDialogAdding.tsx

@@ -65,9 +65,6 @@ const AssetGroupDialogAdding: FunctionComponent<Props> = ({
   // Pagination
   const [assetGroups, setAssetGroups] = useState<AssetGroupOutput[]>([]);
 
-  const availableFilterNames = [
-    'asset_group_tags',
-  ];
   const { queryableHelpers, searchPaginationInput } = useQueryable(buildSearchPagination({}));
 
   const paginationComponent = (
@@ -76,7 +73,7 @@ const AssetGroupDialogAdding: FunctionComponent<Props> = ({
       searchPaginationInput={searchPaginationInput}
       setContent={setAssetGroups}
       entityPrefix="asset_group"
-      availableFilterNames={availableFilterNames}
+      availableFilterNames={['asset_group_tags']}
       queryableHelpers={queryableHelpers}
     />
   );