Fix primefaces#10681: JPALazyDataModel case sensitive filters

melloware · Sep 19, 2023 · 8c9bb19 · 8c9bb19
1 parent c501228
commit 8c9bb19
Show file tree

Hide file tree

Showing 3 changed files with 55 additions and 8 deletions.
diff --git a/docs/14_0_0/components/datatable.md b/docs/14_0_0/components/datatable.md
@@ -944,13 +944,27 @@ new JpaLazyDataModel<>(MyEntity.class, () -> entityManager);
 If you have selection enabled, you can either pass the rowKey field name in the constructor:
 
 ```java
-new JpaLazyDataModel<>(MyEntity.class, () -> entityManager, "id");
+JpaLazyDataModel<MyEntity> lazyDataModel = JpaLazyDataModel.builder(MyEntity.class, () -> entityManager)
+    .rowKeyField("id")
+    .build();
 ```
 
 or provide a existing JSF `Converter`:
 
 ```java
 new JpaLazyDataModel<>(MyEntity.class, () -> entityManager, myConverter);
+```java
+JpaLazyDataModel<MyEntity> lazyDataModel = JpaLazyDataModel.builder(MyEntity.class, () -> entityManager)
+    .rowKeyConverter(myConverter)
+    .build();
+```
+
+or use the builder pattern to enable case insensitive searching and other features:
+
+```java
+JpaLazyDataModel<MyEntity> lazyDataModel = JpaLazyDataModel.builder(MyEntity.class, () -> entityManager)
+    .caseSensitive(false)
+    .build();
 ```
 
 Also you can add global filters via:

diff --git a/docs/14_0_0/gettingstarted/whatsnew.md b/docs/14_0_0/gettingstarted/whatsnew.md
@@ -20,6 +20,10 @@ Look into [migration guide](https://primefaces.github.io/primefaces/14_0_0/#/../
 
 * DataExporter
     * Added `bufferSize` to control how many items are fetched at a time when `DataTable#lazy` is enabled
+
+* DataTable
+    * JPALazyDataModel now supports case insensitive filters with `setCaseSensitive(false);`
+    * JPALazyDataModel now supports builder pattern for constructor.
 
 ### PrimeFaces Selenium 
 

diff --git a/primefaces/src/main/java/org/primefaces/model/JpaLazyDataModel.java b/primefaces/src/main/java/org/primefaces/model/JpaLazyDataModel.java
@@ -61,6 +61,7 @@ public class JpaLazyDataModel<T> extends LazyDataModel<T> implements Serializabl
     protected Class<T> entityClass;
     protected SerializableSupplier<EntityManager> entityManager;
     protected String rowKeyField;
+    protected boolean caseSensitive = true;
 
     private transient Lazy<Method> rowKeyGetter;
 
@@ -194,25 +195,28 @@ protected void applyGlobalFilters(Map<String, FilterMeta> filterBy, CriteriaBuil
     protected Predicate createPredicate(FilterMeta filter, Field filterField,
             Root<T> root, CriteriaBuilder cb, Expression fieldExpression, Object filterValue) {
 
-        Lazy<Expression<String>> fieldExpressionAsString = new Lazy(() -> fieldExpression.as(String.class));
+        Lazy<Expression<String>> fieldExpressionAsString = new Lazy(() -> caseSensitive
+                ? fieldExpression.as(String.class)
+                : cb.upper(fieldExpression.as(String.class)));
         Lazy<Collection<Object>> filterValueAsCollection = new Lazy(
                 () -> filterValue.getClass().isArray() ? Arrays.asList((Object[]) filterValue)
                         : (Collection<Object>) filterValue);
 
         switch (filter.getMatchMode()) {
             case STARTS_WITH:
-                return cb.like(fieldExpressionAsString.get(), filterValue + "%");
+                return cb.like(fieldExpressionAsString.get(), getStringFilterValue(filterValue) + "%");
             case NOT_STARTS_WITH:
-                return cb.notLike(fieldExpressionAsString.get(), filterValue + "%");
+                return cb.notLike(fieldExpressionAsString.get(), getStringFilterValue(filterValue) + "%");
             case ENDS_WITH:
-                return cb.like(fieldExpressionAsString.get(), "%" + filterValue);
+                return cb.like(fieldExpressionAsString.get(), "%" + getStringFilterValue(filterValue));
             case NOT_ENDS_WITH:
-                return cb.notLike(fieldExpressionAsString.get(), "%" + filterValue);
+                return cb.notLike(fieldExpressionAsString.get(), "%" + getStringFilterValue(filterValue));
             case CONTAINS:
-                return cb.like(fieldExpressionAsString.get(), "%" + filterValue + "%");
+                return cb.like(fieldExpressionAsString.get(), "%" + getStringFilterValue(filterValue) + "%");
             case NOT_CONTAINS:
-                return cb.notLike(fieldExpressionAsString.get(), "%" + filterValue + "%");
+                return cb.notLike(fieldExpressionAsString.get(), "%" + getStringFilterValue(filterValue) + "%");
             case EXACT:
+                return cb.equal(fieldExpressionAsString.get(), getStringFilterValue(filterValue));
             case EQUALS:
                 return cb.equal(fieldExpression, filterValue);
             case NOT_EXACT:
@@ -249,6 +253,10 @@ protected Predicate createPredicate(FilterMeta filter, Field filterField,
         return null;
     }
 
+    protected Object getStringFilterValue(Object filterValue) {
+        return caseSensitive ? filterValue : filterValue.toString().toUpperCase(Locale.getDefault());
+    }
+
     protected void applySort(CriteriaBuilder cb,
                              CriteriaQuery<T> cq,
                              Root<T> root,
@@ -407,7 +415,21 @@ protected Method getRowKeyGetter() {
         return rowKeyGetter.get();
     }
 
+    public String getRowKeyField() {
+        return rowKeyField;
+    }
+
+    public void setRowKeyField(String rowKeyField) {
+        this.rowKeyField = rowKeyField;
+    }
+
+    public boolean isCaseSensitive() {
+        return caseSensitive;
+    }
 
+    public void setCaseSensitive(boolean caseSensitive) {
+        this.caseSensitive = caseSensitive;
+    }
 
     public static <T> Builder<T> builder(Class<T> entityClass, SerializableSupplier<EntityManager> entityManager) {
         return new Builder<>(entityClass, entityManager);
@@ -418,6 +440,7 @@ public static class Builder<T> {
         private final SerializableSupplier<EntityManager> entityManager;
         private String rowKeyField;
         private Converter<T> rowKeyConverter;
+        private boolean caseSensitive = true;
 
         public Builder(Class<T> entityClass, SerializableSupplier<EntityManager> entityManager) {
             this.entityClass = entityClass;
@@ -434,6 +457,11 @@ public Builder<T> rowKeyField(String rowKeyField) {
             return this;
         }
 
+        public Builder<T> caseSensitive(boolean caseSensitive) {
+            this.caseSensitive = caseSensitive;
+            return this;
+        }
+
         public JpaLazyDataModel<T> build() {
             JpaLazyDataModel<T> model = new JpaLazyDataModel<>(entityClass, entityManager);
             if (rowKeyField != null) {
@@ -442,6 +470,7 @@ public JpaLazyDataModel<T> build() {
             if (rowKeyConverter != null) {
                 model.setRowKeyConverter(rowKeyConverter);
             }
+            model.caseSensitive = caseSensitive;
             return model;
         }
     }