Merge pull request #13825 from SORMAS-Foundation/bug/13428-disease-config-table-sorting

FIX: 13428: Sorting DiseaseConfiguration.

Author: obinna-h-n

sormas-backend/src/main/java/de/symeda/sormas/backend/common/sort/EntitySortUtils.java

@@ -0,0 +1,73 @@
+package de.symeda.sormas.backend.common.sort;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.Expression;
+import javax.persistence.criteria.Root;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Utility class to be able to create sorting criterias on entities without using switch cases.
+ *
+ * Example:
+ *
+ * public static final Map<String, BiFunction<CriteriaBuilder, Root<DiseaseConfiguration>, Expression<?>>> SORTABLE_FIELDS_DICTIONARY =
+ * EntitySortUtils.defaultSort(
+ * DiseaseConfiguration.DISEASE,
+ * DiseaseConfiguration.ACTIVE,
+ * DiseaseConfiguration.PRIMARY_DISEASE,
+ * DiseaseConfiguration.CASE_SURVEILLANCE_ENABLED,
+ * DiseaseConfiguration.AGGREGATE_REPORTING_ENABLED,
+ * DiseaseConfiguration.FOLLOW_UP_ENABLED,
+ * DiseaseConfiguration.FOLLOW_UP_DURATION,
+ * DiseaseConfiguration.CASE_FOLLOW_UP_DURATION,
+ * DiseaseConfiguration.EVENT_PARTICIPANT_FOLLOW_UP_DURATION,
+ * DiseaseConfiguration.EXTENDED_CLASSIFICATION,
+ * DiseaseConfiguration.EXTENDED_CLASSIFICATION_MULTI,
+ * DiseaseConfiguration.AUTOMATIC_SAMPLE_ASSIGNMENT_THRESHOLD);
+ */
+public class EntitySortUtils {
+
+	private EntitySortUtils() {
+	}
+
+	/**
+	 * Will use the field name itself for sorting without any transformation.
+	 * 
+	 * @param fieldNames
+	 *            name of the filterable fields (must be exhaustive)
+	 * @return dictionary with key being a field and value being a bifunction returning the value without transformations.
+	 * @param <T>
+	 *            Type information is important for Hibernate to prepare the adequate statements
+	 */
+	public static <T> Map<String, BiFunction<CriteriaBuilder, Root<T>, Expression<?>>> defaultSort(String... fieldNames) {
+		return Arrays.stream(fieldNames).collect(Collectors.toMap(fieldName -> fieldName, defaultSort()));
+	}
+
+	/**
+	 * Will use the field name itself for sorting by returning the lowercase values of the fields.
+	 *
+	 * @param fieldNames
+	 *            name of the filterable fields (must be exhaustive)
+	 * @return dictionary with key being a field and value being a bifunction returning the lower case value.
+	 * @param <T>
+	 *            Type information is important for Hibernate to prepare the adequate statements
+	 */
+	public static <T> Map<String, BiFunction<CriteriaBuilder, Root<T>, Expression<?>>> lowerCaseSort(String... fieldNames) {
+		return Arrays.stream(fieldNames).collect(Collectors.toMap(fieldName -> fieldName, lowerCaseSort()));
+	}
+
+	public static @NotNull <T> Function<String, BiFunction<CriteriaBuilder, Root<T>, Expression<?>>> defaultSort() {
+		return fieldName -> (criteriaBuilder, root) -> root.get(fieldName);
+	}
+
+	public static @NotNull <T> Function<String, BiFunction<CriteriaBuilder, Root<T>, Expression<?>>> lowerCaseSort() {
+		return fieldName -> (criteriaBuilder, root) -> criteriaBuilder.lower(root.get(fieldName));
+	}
+}

sormas-backend/src/main/java/de/symeda/sormas/backend/disease/DiseaseConfiguration.java

@@ -27,6 +27,13 @@ public class DiseaseConfiguration extends AbstractDomainObject {
 	public static final String PRIMARY_DISEASE = "primaryDisease";
 	public static final String CASE_SURVEILLANCE_ENABLED = "caseSurveillanceEnabled";
 	public static final String AGGREGATE_REPORTING_ENABLED = "aggregateReportingEnabled";
+	public static final String FOLLOW_UP_ENABLED = "followUpEnabled";
+	public static final String FOLLOW_UP_DURATION = "followUpDuration";
+	public static final String CASE_FOLLOW_UP_DURATION = "caseFollowUpDuration";
+	public static final String EVENT_PARTICIPANT_FOLLOW_UP_DURATION = "eventParticipantFollowUpDuration";
+	public static final String EXTENDED_CLASSIFICATION = "extendedClassification";
+	public static final String EXTENDED_CLASSIFICATION_MULTI = "extendedClassificationMulti";
+	public static final String AUTOMATIC_SAMPLE_ASSIGNMENT_THRESHOLD = "automaticSampleAssignmentThreshold";
 
 	private Disease disease;
 	private Boolean active;

sormas-backend/src/main/java/de/symeda/sormas/backend/disease/DiseaseConfigurationFacadeEjb.java

@@ -25,7 +25,9 @@
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
+import java.util.function.BiFunction;
 import java.util.stream.Collectors;
 
 import javax.annotation.PostConstruct;
@@ -37,6 +39,7 @@
 import javax.ejb.Stateless;
 import javax.persistence.criteria.CriteriaBuilder;
 import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Expression;
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Root;
 import javax.validation.constraints.NotNull;
@@ -53,6 +56,7 @@
 import de.symeda.sormas.api.disease.DiseaseConfigurationIndexDto;
 import de.symeda.sormas.api.user.UserRight;
 import de.symeda.sormas.api.utils.SortProperty;
+import de.symeda.sormas.backend.common.sort.EntitySortUtils;
 import de.symeda.sormas.backend.user.User;
 import de.symeda.sormas.backend.user.UserService;
 import de.symeda.sormas.backend.util.DtoHelper;
@@ -61,6 +65,21 @@
 @Stateless(name = "DiseaseConfigurationFacade")
 public class DiseaseConfigurationFacadeEjb implements DiseaseConfigurationFacade {
 
+	public static final Map<String, BiFunction<CriteriaBuilder, Root<DiseaseConfiguration>, Expression<?>>> SORTABLE_FIELDS_DICTIONARY =
+		EntitySortUtils.defaultSort(
+			DiseaseConfiguration.DISEASE,
+			DiseaseConfiguration.ACTIVE,
+			DiseaseConfiguration.PRIMARY_DISEASE,
+			DiseaseConfiguration.CASE_SURVEILLANCE_ENABLED,
+			DiseaseConfiguration.AGGREGATE_REPORTING_ENABLED,
+			DiseaseConfiguration.FOLLOW_UP_ENABLED,
+			DiseaseConfiguration.FOLLOW_UP_DURATION,
+			DiseaseConfiguration.CASE_FOLLOW_UP_DURATION,
+			DiseaseConfiguration.EVENT_PARTICIPANT_FOLLOW_UP_DURATION,
+			DiseaseConfiguration.EXTENDED_CLASSIFICATION,
+			DiseaseConfiguration.EXTENDED_CLASSIFICATION_MULTI,
+			DiseaseConfiguration.AUTOMATIC_SAMPLE_ASSIGNMENT_THRESHOLD);
+
 	protected final Logger logger = LoggerFactory.getLogger(getClass());
 
 	@EJB
@@ -135,16 +154,26 @@ public List<DiseaseConfigurationIndexDto> getIndexList(
 			cq.where(filter);
 		}
 
-		cq.orderBy(cb.asc(root.get(DiseaseConfiguration.DISEASE)), cb.asc(root.get(DiseaseConfiguration.ACTIVE)));
+		if (CollectionUtils.isNotEmpty(sortProperties)) {
+			cq.orderBy(sortProperties.stream().map(sortProperty -> {
+				String sortPropertyName = sortProperty.propertyName;
+				Expression<?> sortExpression = Optional.ofNullable(SORTABLE_FIELDS_DICTIONARY.get(sortPropertyName))
+					.map(fct -> fct.apply(cb, root))
+					.orElseThrow(
+						() -> new IllegalArgumentException(
+							String.format(
+								"Invalid sort property: [%s] for [%s]. If must be sorted, then must be added into SORTABLE_FIELDS_DICTIONARY ",
+								sortPropertyName,
+								DiseaseConfiguration.class.getSimpleName())));
+				return sortProperty.ascending ? cb.asc(sortExpression) : cb.desc(sortExpression);
+			}).collect(Collectors.toList()));
+		} else {
+			cq.orderBy(cb.asc(root.get(DiseaseConfiguration.DISEASE)), cb.asc(root.get(DiseaseConfiguration.ACTIVE)));
+		}
 
 		cq.select(root);
 
-		List<DiseaseConfigurationIndexDto> resultList = getResultList(service.getEntityManager(), cq, first, max, this::toIndexDto);
-		for (DiseaseConfigurationIndexDto dto : resultList) {
-
-		}
-
-		return resultList;
+		return getResultList(service.getEntityManager(), cq, first, max, this::toIndexDto);
 	}
 
 	private DiseaseConfigurationIndexDto toIndexDto(DiseaseConfiguration entity) {

sormas-ui/src/main/java/de/symeda/sormas/ui/EnumSortUtils.java

@@ -0,0 +1,27 @@
+package de.symeda.sormas.ui;
+
+import java.util.Comparator;
+import java.util.function.Function;
+
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * Warning by default Vaadin uses {@link Comparable#compareTo( Object)}
+ * By default, enums are sorted using {@link Enum#ordinal()} which is a bad pick for "human-intuitive-sorting",
+ * provides some utility methods to simplify this endeavor.
+ * <p>
+ * Could be further enhanced by using: Vaadin's SerializableComparator class, but not done to avoid additional vaadin-server dependency.
+ */
+public class EnumSortUtils {
+
+	private EnumSortUtils() {
+	}
+
+	public static <T, U extends Enum<?>> Comparator<T> comparingOnEnumField(Function<? super T, ? extends U> keyExtractor) {
+		return Comparator.nullsLast(Comparator.comparing(keyExtractor, enumNameComparator()));
+	}
+
+	public static <T extends Enum<?>> Comparator<T> enumNameComparator() {
+		return Comparator.nullsLast(Comparator.comparing(Enum::name, StringUtils::compare));
+	}
+}

sormas-ui/src/main/java/de/symeda/sormas/ui/configuration/disease/DiseaseConfigurationGrid.java

@@ -15,6 +15,10 @@
 
 package de.symeda.sormas.ui.configuration.disease;
 
+import static de.symeda.sormas.ui.EnumSortUtils.comparingOnEnumField;
+
+import java.util.List;
+
 import de.symeda.sormas.api.FacadeProvider;
 import de.symeda.sormas.api.disease.DiseaseConfigurationCriteria;
 import de.symeda.sormas.api.disease.DiseaseConfigurationDto;
@@ -33,9 +37,12 @@ public DiseaseConfigurationGrid(DiseaseConfigurationCriteria criteria) {
 		super(DiseaseConfigurationIndexDto.class);
 		setSizeFull();
 
-		setLazyDataProvider(FacadeProvider.getDiseaseConfigurationFacade()::getIndexList, FacadeProvider.getDiseaseConfigurationFacade()::count);
+		setInEagerMode(true);
+
 		setCriteria(criteria);
 
+		setEagerDataProvider();
+
 		setColumns(
 			DiseaseConfigurationIndexDto.DISEASE,
 			DiseaseConfigurationIndexDto.ACTIVE,
@@ -51,6 +58,8 @@ public DiseaseConfigurationGrid(DiseaseConfigurationCriteria criteria) {
 			DiseaseConfigurationIndexDto.EXTENDED_CLASSIFICATION_MULTI,
 			DiseaseConfigurationIndexDto.AUTOMATIC_SAMPLE_ASSIGNMENT_THRESHOLD);
 
+		getColumn(DiseaseConfigurationIndexDto.AGE_GROUPS).setSortable(false);
+
 		addEditColumn(e -> ControllerProvider.getDiseaseConfirgurationController().editDiseaseConfiguration(e.getUuid()));
 
 		for (Column<?, ?> column : getColumns()) {
@@ -64,9 +73,17 @@ public DiseaseConfigurationGrid(DiseaseConfigurationCriteria criteria) {
 		getColumn(DiseaseConfigurationIndexDto.EXTENDED_CLASSIFICATION).setRenderer(new BooleanRenderer());
 		getColumn(DiseaseConfigurationIndexDto.EXTENDED_CLASSIFICATION_MULTI).setRenderer(new BooleanRenderer());
 		getColumn(DiseaseConfigurationIndexDto.AGGREGATE_REPORTING_ENABLED).setRenderer(new BooleanRenderer());
+
+		getColumn(DiseaseConfigurationIndexDto.DISEASE)
+			.setComparator((o1, o2) -> comparingOnEnumField(DiseaseConfigurationIndexDto::getDisease).compare(o1, o2));
+
+	}
+
+	private void setEagerDataProvider() {
+		setDataProvider(FacadeProvider.getDiseaseConfigurationFacade().getIndexList(getCriteria(), null, null, List.of()).stream());
 	}
 
 	public void reload() {
-		getDataProvider().refreshAll();
+		setEagerDataProvider();
 	}
 }

sormas-ui/src/test/java/de/symeda/sormas/ui/EnumSortUtilsTest.java

@@ -0,0 +1,47 @@
+package de.symeda.sormas.ui;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+import de.symeda.sormas.api.Disease;
+
+class EnumSortUtilsTest {
+
+	@Test
+	void testComparingOnEnumField_sortsByEnumFieldName() {
+		class DiseaseHolder {
+
+			final Disease disease;
+
+			DiseaseHolder(Disease d) {
+				this.disease = d;
+			}
+
+			Disease getDisease() {
+				return disease;
+			}
+		}
+
+		List<DiseaseHolder> list = Arrays.asList(
+			null,
+			new DiseaseHolder(Disease.MEASLES),
+			new DiseaseHolder(Disease.ANTHRAX),
+			new DiseaseHolder(Disease.CORONAVIRUS),
+			new DiseaseHolder(null));
+
+		Comparator<DiseaseHolder> comparator = EnumSortUtils.comparingOnEnumField(DiseaseHolder::getDisease);
+
+		List<DiseaseHolder> sorted = list.stream().sorted(comparator).collect(Collectors.toList());
+
+		List<Disease> resultOrder =
+			sorted.stream().map(diseaseHolder -> diseaseHolder != null ? diseaseHolder.getDisease() : null).collect(Collectors.toList());
+
+		assertEquals(Arrays.asList(Disease.ANTHRAX, Disease.CORONAVIRUS, Disease.MEASLES, null, null), resultOrder);
+	}
+}