task: Add support for ignore case in eq and neq

build.gradle.kts

@@ -30,8 +30,8 @@ if (hasProperty("release")) {
             sonatype {
                 username.set(ossrhUsername)
                 password.set(ossrhPassword)
-                nexusUrl.set(uri("https://s01.oss.sonatype.org/service/local/"))
-                snapshotRepositoryUrl.set(uri("https://s01.oss.sonatype.org/content/repositories/snapshots/"))
+                nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
+                snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))
             }
         }
     }

crud-framework-core/src/main/java/dev/krud/crudframework/modelfilter/FilterFields.java

@@ -26,6 +26,10 @@ public static FilterField eq(String fieldName, String value) {
 		return createFilterField(fieldName, FilterFieldOperation.Equal, FilterFieldDataType.String, null, value);
 	}
 
+    public static FilterField eqic(String fieldName, String value) {
+        return createFilterField(fieldName, FilterFieldOperation.EqualIgnoreCase, FilterFieldDataType.String, null, value);
+    }
+
 	public static FilterField eq(String fieldName, Integer value) {
 		return createFilterField(fieldName, FilterFieldOperation.Equal, FilterFieldDataType.Integer, null, value);
 	}
@@ -62,6 +66,10 @@ public static FilterField ne(String fieldName, String value) {
 		return createFilterField(fieldName, FilterFieldOperation.NotEqual, FilterFieldDataType.String, null, value);
 	}
 
+    public static FilterField neic(String fieldName, String value) {
+        return createFilterField(fieldName, FilterFieldOperation.NotEqualIgnoreCase, FilterFieldDataType.String, null, value);
+    }
+
 	public static FilterField ne(String fieldName, Integer value) {
 		return createFilterField(fieldName, FilterFieldOperation.NotEqual, FilterFieldDataType.Integer, null, value);
 	}

crud-framework-core/src/main/java/dev/krud/crudframework/modelfilter/dsl/FilterFieldsBuilder.kt

@@ -22,6 +22,15 @@ class FilterFieldsBuilder<RootType : PersistentEntity>(private val filterFields:
         )
     }
 
+    infix fun KProperty1<RootType, String?>.EqualIgnoreCase(target: String) {
+        filterFields += FilterField(
+            effectiveName,
+            FilterFieldOperation.EqualIgnoreCase,
+            FilterFieldDataType.String,
+            target
+        )
+    }
+
     infix fun KProperty1<RootType, Int?>.Equal(target: Int) {
         filterFields += FilterField(
             effectiveName,
@@ -94,6 +103,15 @@ class FilterFieldsBuilder<RootType : PersistentEntity>(private val filterFields:
         )
     }
 
+    infix fun KProperty1<RootType, String?>.NotEqualIgnoreCase(target: String) {
+        filterFields += FilterField(
+            effectiveName,
+            FilterFieldOperation.NotEqualIgnoreCase,
+            FilterFieldDataType.String,
+            target
+        )
+    }
+
     infix fun KProperty1<RootType, Int?>.NotEqual(target: Int) {
         filterFields += FilterField(
             effectiveName,

crud-framework-core/src/main/java/dev/krud/crudframework/modelfilter/enums/FilterFieldOperation.kt

@@ -2,7 +2,9 @@ package dev.krud.crudframework.modelfilter.enums
 
 enum class FilterFieldOperation(val junction: Boolean = false) {
     Equal,
+    EqualIgnoreCase,
     NotEqual,
+    NotEqualIgnoreCase,
     In,
     NotIn,
     GreaterThan,

crud-framework-core/src/main/java/dev/krud/crudframework/util/DynamicModelFilterUtils.kt

@@ -60,9 +60,15 @@ fun FilterField.filtersMatch(target: Any): Boolean {
         FilterFieldOperation.Equal -> {
             return actualValue == this.value1()
         }
+        FilterFieldOperation.EqualIgnoreCase -> {
+            return actualValue.toString().lowercase() == this.value1().toString().lowercase()
+        }
         FilterFieldOperation.NotEqual -> {
             return actualValue != this.value1()
         }
+        FilterFieldOperation.NotEqualIgnoreCase -> {
+            return actualValue.toString().lowercase() != this.value1().toString().lowercase()
+        }
         FilterFieldOperation.In -> {
             return this.value1() in actualValue as Collection<*>
         }

crud-framework-core/src/test/java/dev/krud/crudframework/modelfilter/dsl/FilterFieldDslTest.kt

@@ -56,6 +56,21 @@ class FilterFieldDslTest {
         )
     }
 
+    @Test
+    fun `test EqualIgnoreCase#String`() {
+        val filterField = and<TestClazz> {
+            TestClazz::testString EqualIgnoreCase "value"
+        }.children.first()
+
+        filterField.runAssertions(
+            "testString",
+            FilterFieldOperation.EqualIgnoreCase,
+            FilterFieldDataType.String,
+            1,
+            arrayOf("value")
+        )
+    }
+
     @Test
     fun `test Equal#Int`() {
         val filterField = and<TestClazz> {
@@ -162,6 +177,21 @@ class FilterFieldDslTest {
         )
     }
 
+    @Test
+    fun `test NotEqualIgnoreCase#String`() {
+        val filterField = and<TestClazz> {
+            TestClazz::testString NotEqualIgnoreCase "value"
+        }.children.first()
+
+        filterField.runAssertions(
+            "testString",
+            FilterFieldOperation.NotEqualIgnoreCase,
+            FilterFieldDataType.String,
+            1,
+            arrayOf("value")
+        )
+    }
+
     @Test
     fun `test NotEqual#Int`() {
         val filterField = and<TestClazz> {

crud-framework-core/src/test/java/dev/krud/crudframework/util/DynamicModelFilterUtilsTest.kt

@@ -65,6 +65,32 @@ class DynamicModelFilterUtilsTest {
         ).isFalse()
     }
 
+    @Test
+    fun `test EqualIgnoreCase operation happy flow`() {
+        val customer = Customer()
+        val filter = where<Customer> {
+            Customer::address Sub {
+                Address::street EqualIgnoreCase "example street"
+            }
+        }
+        expectThat(
+            filter.filtersMatch(customer)
+        ).isTrue()
+    }
+
+    @Test
+    fun `test EqualIgnoreCase operation with false outcome`() {
+        val customer = Customer()
+        val filter = where<Customer> {
+            Customer::address Sub {
+                Address::street Equal "example"
+            }
+        }
+        expectThat(
+            filter.filtersMatch(customer)
+        ).isFalse()
+    }
+
     @Test
     fun `test NotEqual operation happy flow`() {
         val customer = Customer()
@@ -91,6 +117,32 @@ class DynamicModelFilterUtilsTest {
         ).isFalse()
     }
 
+    @Test
+    fun `test NotEqualIgnoreCase operation happy flow`() {
+        val customer = Customer()
+        val filter = where<Customer> {
+            Customer::address Sub {
+                Address::street NotEqualIgnoreCase "example"
+            }
+        }
+        expectThat(
+            filter.filtersMatch(customer)
+        ).isTrue()
+    }
+
+    @Test
+    fun `test NotEqualIgnoreCase operation with false outcome`() {
+        val customer = Customer()
+        val filter = where<Customer> {
+            Customer::address Sub {
+                Address::street NotEqualIgnoreCase "example street"
+            }
+        }
+        expectThat(
+            filter.filtersMatch(customer)
+        ).isFalse()
+    }
+
     @Test
     fun `test GreaterThan operation happy flow`() {
         val customer = Customer()

crud-framework-hibernate5-connector/src/main/java/dev/krud/crudframework/jpa/dao/JpaDaoImpl.kt

@@ -110,10 +110,26 @@ class JpaDaoImpl : CrudDao {
                 equal(root.getExpressionByFieldName(filterField.fieldName), filterField.value1())
             }
 
+            FilterFieldOperation.EqualIgnoreCase -> {
+                val path = root.getExpressionByFieldName(filterField.fieldName) as Path<String>
+                equal(
+                    lower(path),
+                    filterField.value1()?.toString()?.lowercase()
+                )
+            }
+
             FilterFieldOperation.NotEqual -> {
                 notEqual(root.getExpressionByFieldName(filterField.fieldName), filterField.value1())
             }
 
+            FilterFieldOperation.NotEqualIgnoreCase -> {
+                val path = root.getExpressionByFieldName(filterField.fieldName) as Path<String>
+                notEqual(
+                    lower(path),
+                    filterField.value1()?.toString()?.lowercase()
+                )
+            }
+
             FilterFieldOperation.In -> {
                 `in`(root.getExpressionByFieldName(filterField.fieldName)).value(filterField.values.toList())
             }