refactor RuleEvent to kotlin

src/main/java/org/hisp/dhis/rules/RuleVariableValueMapBuilder.java

@@ -239,7 +239,7 @@ private Map<String, List<RuleDataValue>> buildAllEventValues()
         }
 
         // sort list of events by eventDate:
-        events.sort(RuleEvent.EVENT_DATE_COMPARATOR);
+        events.sort(RuleEvent.Companion.getEVENT_DATE_COMPARATOR());
 
         // aggregating values by data element uid
         for ( int i = 0; i < events.size(); i++ )

src/main/java/org/hisp/dhis/rules/models/RuleEvent.kt

@@ -0,0 +1,71 @@
+package org.hisp.dhis.rules.models
+
+import java.util.*
+import java.util.Comparator.comparing
+import kotlin.Comparator
+
+data class RuleEvent(
+    val event: String,
+    val programStage: String,
+    val programStageName: String,
+    val status: Status,
+    val eventDate: Date,
+    val dueDate: Date?,
+    val completedDate: Date?,
+    val organisationUnit: String,
+    val organisationUnitCode: String?,
+    val dataValues: List<RuleDataValue>
+) {
+    enum class Status {
+        ACTIVE,
+        COMPLETED,
+        SCHEDULE,
+        SKIPPED,
+        VISITED,
+        OVERDUE
+    }
+
+    fun event(): String {
+        return event
+    }
+
+    fun programStage(): String {
+        return programStage
+    }
+
+    fun programStageName(): String {
+        return programStageName
+    }
+
+    fun status(): Status {
+        return status
+    }
+
+    fun eventDate(): Date {
+        return eventDate
+    }
+
+    fun dueDate(): Date? {
+        return dueDate
+    }
+
+    fun completedDate(): Date? {
+        return completedDate
+    }
+
+    fun organisationUnit(): String {
+        return organisationUnit
+    }
+
+    fun organisationUnitCode(): String? {
+        return organisationUnitCode
+    }
+
+    fun dataValues(): List<RuleDataValue> {
+        return dataValues
+    }
+
+    companion object {
+        val EVENT_DATE_COMPARATOR: Comparator<RuleEvent> = Comparator.comparing{e: RuleEvent-> e.eventDate()}.reversed()
+    }
+}

src/test/java/org/hisp/dhis/rules/ConstantsValueTest.kt

@@ -1,7 +1,6 @@
 package org.hisp.dhis.rules
 
 import org.hisp.dhis.rules.models.*
-import org.hisp.dhis.rules.util.MockRuleVariable
 import java.util.*
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -54,13 +53,12 @@ class ConstantsValueTest {
             .build()
         val ruleEngine = ruleEngineBuilder.build()
         val ruleEffects = ruleEngine.evaluate(enrollment).call()
-        assertEquals(1, ruleEffects.size.toLong())
+        assertEquals(1, ruleEffects.size)
         assertEquals("3.14", ruleEffects[0].data())
         assertEquals(assignAction, ruleEffects[0].ruleAction())
     }
 
     @Test
-    @Throws(Exception::class)
     fun assignValue() {
         val assignAction: RuleAction = RuleActionAssign.create(null, "4", "test_attribute")
         val action: RuleAction =
@@ -83,15 +81,14 @@ class ConstantsValueTest {
             .build()
         val ruleEngine = ruleEngineBuilder.build()
         val ruleEffects = ruleEngine.evaluate(enrollment).call()
-        assertEquals(2, ruleEffects.size.toLong())
+        assertEquals(2, ruleEffects.size)
         assertEquals("4", ruleEffects[0].data())
         assertEquals(assignAction, ruleEffects[0].ruleAction())
         assertEquals("4", ruleEffects[1].data())
         assertEquals(action, ruleEffects[1].ruleAction())
     }
 
     @Test
-    @Throws(Exception::class)
     fun assignValueThroughVariable() {
         val assignAction: RuleAction = RuleActionAssign.create("#{test_attribute}", "4", null)
         val action: RuleAction =
@@ -114,40 +111,29 @@ class ConstantsValueTest {
             .build()
         val ruleEngine = ruleEngineBuilder.build()
         val ruleEffects = ruleEngine.evaluate(enrollment).call()
-        assertEquals(1, ruleEffects.size.toLong())
+        assertEquals(1, ruleEffects.size)
         assertEquals("4", ruleEffects[0].data())
         assertEquals(action, ruleEffects[0].ruleAction())
     }
 
     @Test
-    @Throws(Exception::class)
     fun assignConstantValueFromAssignActionInEvent() {
         val assignAction: RuleAction = RuleActionAssign.create(null, "C{A1234567890}", "#{test_data_element}")
         val rule: Rule = Rule("true", java.util.List.of(assignAction), "test_program_rule1", "")
         val constantsValueMap: MutableMap<String, String> = HashMap()
         constantsValueMap["A1234567890"] = "3.14"
         val ruleEngineBuilder = getRuleEngine(java.util.List.of(rule), constantsValueMap)
-        val ruleEvent = RuleEvent.builder()
-            .event("test_event")
-            .programStage("test_program_stage")
-            .programStageName("")
-            .status(RuleEvent.Status.ACTIVE)
-            .eventDate(Date())
-            .dueDate(Date())
-            .organisationUnit("")
-            .organisationUnitCode("")
-            .completedDate(Date())
-            .dataValues(
-                java.util.List.of(
+        val ruleEvent = RuleEvent(event ="test_event", programStage = "test_program_stage", programStageName = "",
+            status = RuleEvent.Status.ACTIVE, eventDate = Date(), dueDate = Date(), organisationUnit = "", organisationUnitCode = "", completedDate = Date(), dataValues =
+            listOf(
                     RuleDataValue.create(
                         Date(), "test_program_stage", "test_data_element", "test_value"
                     )
                 )
             )
-            .build()
         val ruleEngine = ruleEngineBuilder.build()
         val ruleEffects = ruleEngine.evaluate(ruleEvent).call()
-        assertEquals(1, ruleEffects.size.toLong())
+        assertEquals(1, ruleEffects.size)
         assertEquals("3.14", ruleEffects[0].data())
         assertEquals(assignAction, ruleEffects[0].ruleAction())
     }