In-memory sorting of roles returned by RoleService#search

src/main/java/eu/europa/ec/simpl/usersroles/services/impl/RoleServiceImpl.java

@@ -21,6 +21,7 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import lombok.SneakyThrows;
@@ -228,10 +229,7 @@ public class RoleServiceImpl implements RoleService {
         return sort.stream()
                 .flatMap(order -> {
                     try {
-                        return Optional.ofNullable(BeanUtils.getPropertyDescriptor(RoleDTO.class, order.getProperty()))
-                                .map(property ->
-                                        Comparator.<RoleDTO, Comparable<Object>>comparing(o -> get(o, property)))
-                                .stream();
+                        return Optional.ofNullable(getPropertyDescriptor(order)).flatMap(toComparator(order)).stream();
                     } catch (BeansException e) {
                         return Stream.empty();
                     }
@@ -240,6 +238,31 @@ public class RoleServiceImpl implements RoleService {
                 .orElse(unsortedComparator());
     }
 
+    private static PropertyDescriptor getPropertyDescriptor(Sort.Order order) {
+        return BeanUtils.getPropertyDescriptor(RoleDTO.class, order.getProperty());
+    }
+
+    private static Function<PropertyDescriptor, Optional<Comparator<RoleDTO>>> toComparator(Sort.Order order) {
+        return property -> toComparator(property, order.getDirection());
+    }
+
+    private static Optional<Comparator<RoleDTO>> toComparator(PropertyDescriptor property, Sort.Direction direction) {
+        if (Comparable.class.isAssignableFrom(property.getPropertyType())) {
+            return buildComparator(property, direction);
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    private static Optional<Comparator<RoleDTO>> buildComparator(
+            PropertyDescriptor property, Sort.Direction direction) {
+        var comparator = Comparator.<RoleDTO, Comparable<Object>>comparing(o -> get(o, property));
+        if (direction == Sort.Direction.DESC) {
+            comparator = comparator.reversed();
+        }
+        return Optional.of(comparator);
+    }
+
     private static Comparator<RoleDTO> unsortedComparator() {
         return (o1, o2) -> 0;
     }