Immutable report params

build.gradle.kts

@@ -1,8 +1,8 @@
+import java.net.URI
 import kotlinx.kover.api.KoverTaskExtension
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.net.URI
 
 plugins {
     kotlin("jvm") version "1.9.22"
@@ -19,6 +19,7 @@ repositories {
 }
 
 apply(plugin = "kotlin")
+
 apply(plugin = "application")
 
 detekt {
@@ -27,9 +28,7 @@ detekt {
     config.setFrom("$projectDir/detekt-config.yml")
 }
 
-ktfmt {
-    kotlinLangStyle()
-}
+ktfmt { kotlinLangStyle() }
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.8.0")
@@ -54,13 +53,7 @@ dependencies {
     testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.2")
 }
 
-kotlin {
-    sourceSets.all {
-        languageSettings {
-            languageVersion = "2.0"
-        }
-    }
-}
+kotlin { sourceSets.all { languageSettings { languageVersion = "2.0" } } }
 
 project.setProperty("mainClassName", "dartzee.main.DartsMainKt")
 
@@ -86,65 +79,51 @@ compileTestKotlin.kotlinOptions {
 }
 
 task<JavaExec>("runDev") {
-    configure(closureOf<JavaExec> {
-        group = "run"
-        classpath = project.the<SourceSetContainer>()["main"].runtimeClasspath
-        args = listOf("devMode", "trueLaunch")
-        mainClass.set("dartzee.main.DartsMainKt")
-    })
-}
-
-kover {
-    filters {
-        classes {
-            excludes.add("dartzee.screen.TestWindow")
+    configure(
+        closureOf<JavaExec> {
+            group = "run"
+            classpath = project.the<SourceSetContainer>()["main"].runtimeClasspath
+            args = listOf("devMode", "trueLaunch")
+            mainClass.set("dartzee.main.DartsMainKt")
         }
-    }
+    )
 }
 
+kover { filters { classes { excludes.add("dartzee.screen.TestWindow") } } }
+
 task<Test>("unitTest") {
     group = "verification"
-    useJUnitPlatform {
-        excludeTags = setOf("integration", "e2e")
-    }
+    useJUnitPlatform { excludeTags = setOf("integration", "e2e") }
 }
 
 task<Test>("updateScreenshots") {
     group = "verification"
-    useJUnitPlatform {
-        includeTags = setOf("screenshot")
-    }
+    useJUnitPlatform { includeTags = setOf("screenshot") }
 
     jvmArgs = listOf("-DupdateSnapshots=true")
 }
 
 task<Test>("integrationAndE2E") {
     group = "verification"
-    useJUnitPlatform {
-        includeTags = setOf("integration", "e2e")
-    }
+    useJUnitPlatform { includeTags = setOf("integration", "e2e") }
 }
 
-tasks {
-    named<Test>("test") {
-        useJUnitPlatform()
-    }
-}
+tasks { named<Test>("test") { useJUnitPlatform() } }
 
 tasks.withType<Test> {
     minHeapSize = "1024m"
     maxHeapSize = "1024m"
 
-    jvmArgs = listOf("-Dcom.sun.management.jmxremote",
-        "-Dcom.sun.management.jmxremote.port=9010",
-        "-Dcom.sun.management.jmxremote.authenticate=false",
-        "-Dcom.sun.management.jmxremote.ssl=false",
-        "-Djava.rmi.server.hostname=localhost",
-        "-DscreenshotOs=linux")
+    jvmArgs =
+        listOf(
+            "-Dcom.sun.management.jmxremote",
+            "-Dcom.sun.management.jmxremote.port=9010",
+            "-Dcom.sun.management.jmxremote.authenticate=false",
+            "-Dcom.sun.management.jmxremote.ssl=false",
+            "-Djava.rmi.server.hostname=localhost"
+        )
 
-    extensions.configure<KoverTaskExtension> {
-        isDisabled.set(name != "unitTest")
-    }
+    extensions.configure<KoverTaskExtension> { isDisabled.set(name != "unitTest") }
 
     testLogging {
         events = mutableSetOf(TestLogEvent.STARTED, TestLogEvent.FAILED)
@@ -153,12 +132,12 @@ tasks.withType<Test> {
 }
 
 tasks.withType<Jar> {
-    manifest {
-        attributes["Main-Class"] = "dartzee.main.DartsMainKt"
-    }
+    manifest { attributes["Main-Class"] = "dartzee.main.DartsMainKt" }
 
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 
     dependsOn(configurations.runtimeClasspath)
-    from(configurations.runtimeClasspath.get().filter { it.name.endsWith("jar") }.map { zipTree(it) })
+    from(
+        configurations.runtimeClasspath.get().filter { it.name.endsWith("jar") }.map { zipTree(it) }
+    )
 }

src/main/kotlin/dartzee/reporting/IncludedPlayerParameters.kt

@@ -3,9 +3,9 @@ package dartzee.reporting
 const val COMPARATOR_SCORE_UNSET = "is unset"
 
 data class IncludedPlayerParameters(
-    var finishingPositions: List<Int> = listOf(),
-    var finalScoreComparator: String = "",
-    var finalScore: Int = -1
+    val finishingPositions: List<Int>,
+    val finalScoreComparator: String,
+    val finalScore: Int?
 ) {
     fun generateExtraWhereSql(alias: String): String {
         val sb = StringBuilder()
@@ -16,7 +16,7 @@ data class IncludedPlayerParameters(
 
         if (finalScoreComparator.equals(COMPARATOR_SCORE_UNSET, ignoreCase = true)) {
             sb.append(" AND $alias.FinalScore = -1")
-        } else if (finalScore > -1) {
+        } else if (finalScore != null) {
             sb.append(" AND $alias.FinalScore $finalScoreComparator $finalScore")
             sb.append(" AND $alias.FinalScore > -1")
         }

src/main/kotlin/dartzee/reporting/ReportParameters.kt

@@ -3,73 +3,58 @@ package dartzee.reporting
 import dartzee.core.util.DateStatics
 import dartzee.core.util.getEndOfTimeSqlString
 import dartzee.core.util.getSqlString
-import dartzee.db.PlayerEntity
 import dartzee.db.SyncAuditEntity
-import dartzee.game.GameType
 import dartzee.utils.InjectedThings.mainDatabase
-import java.sql.Timestamp
-
-class ReportParameters {
-    var gameType: GameType? = null
-    var gameParams = ""
-    var unfinishedOnly = false
-    var dtStartFrom: Timestamp? = null
-    var dtStartTo: Timestamp? = null
-    var dtFinishFrom: Timestamp? = null
-    var dtFinishTo: Timestamp? = null
-    var hmIncludedPlayerToParms = mapOf<PlayerEntity, IncludedPlayerParameters>()
-    var excludedPlayers: List<PlayerEntity> = ArrayList()
-    var excludeOnlyAi: Boolean = false
-    var partOfMatch = MatchFilter.BOTH
-    var pendingChanges: Boolean? = null
+
+data class ReportParameters(val game: ReportParametersGame, val players: ReportParametersPlayers) {
 
     fun getExtraWhereSql(): String {
         val sb = StringBuilder()
 
-        if (gameType != null) {
-            sb.append(" AND g.GameType = '$gameType'")
+        if (game.gameType != null) {
+            sb.append(" AND g.GameType = '${game.gameType}'")
         }
 
-        if (!gameParams.isEmpty()) {
-            sb.append(" AND g.GameParams = '$gameParams'")
+        if (game.gameParams.isNotEmpty()) {
+            sb.append(" AND g.GameParams = '${game.gameParams}'")
         }
 
-        if (dtStartFrom != null) {
+        if (game.dtStartFrom != null) {
             sb.append(" AND g.DtCreation >= '")
-            sb.append(dtStartFrom)
+            sb.append(game.dtStartFrom)
             sb.append("'")
         }
 
-        if (dtStartTo != null) {
+        if (game.dtStartTo != null) {
             sb.append(" AND g.DtCreation <= '")
-            sb.append(dtStartTo)
+            sb.append(game.dtStartTo)
             sb.append("'")
         }
 
-        if (dtFinishFrom != null) {
+        if (game.dtFinishFrom != null) {
             sb.append(" AND g.DtFinish >= '")
-            sb.append(dtFinishFrom)
+            sb.append(game.dtFinishFrom)
             sb.append("'")
         }
 
-        if (dtFinishTo != null) {
+        if (game.dtFinishTo != null) {
             sb.append(" AND g.DtFinish <= '")
-            sb.append(dtFinishTo)
+            sb.append(game.dtFinishTo)
             sb.append("'")
         }
 
-        if (unfinishedOnly) {
+        if (game.unfinishedOnly) {
             sb.append(" AND g.DtFinish = ")
             sb.append(getEndOfTimeSqlString())
         }
 
-        if (partOfMatch == MatchFilter.GAMES_ONLY) {
+        if (game.partOfMatch == MatchFilter.GAMES_ONLY) {
             sb.append(" AND g.DartsMatchId = ''")
-        } else if (partOfMatch == MatchFilter.MATCHES_ONLY) {
+        } else if (game.partOfMatch == MatchFilter.MATCHES_ONLY) {
             sb.append(" AND g.DartsMatchId <> ''")
         }
 
-        pendingChanges?.let { pendingChanges ->
+        game.pendingChanges?.let { pendingChanges ->
             val dtLastSynced =
                 SyncAuditEntity.getLastSyncData(mainDatabase)?.lastSynced
                     ?: DateStatics.START_OF_TIME
@@ -80,7 +65,7 @@ class ReportParameters {
             }
         }
 
-        val it = hmIncludedPlayerToParms.entries.iterator()
+        val it = players.includedPlayers.entries.iterator()
         while (it.hasNext()) {
             val entry = it.next()
             val player = entry.key
@@ -97,14 +82,14 @@ class ReportParameters {
             sb.append(")")
         }
 
-        for (player in excludedPlayers) {
+        for (player in players.excludedPlayers) {
             sb.append(" AND NOT EXISTS (")
             sb.append(" SELECT 1 FROM Participant z")
             sb.append(" WHERE z.PlayerId = '${player.rowId}'")
             sb.append(" AND z.GameId = g.RowId)")
         }
 
-        if (excludeOnlyAi) {
+        if (players.excludeOnlyAi) {
             sb.append(" AND EXISTS (")
             sb.append(" SELECT 1 FROM Participant z, Player p")
             sb.append(" WHERE z.PlayerId = p.RowId")
@@ -114,13 +99,6 @@ class ReportParameters {
 
         return sb.toString()
     }
-
-    override fun toString() =
-        "[$gameType, $gameParams, $dtStartFrom, $dtStartTo, $dtFinishFrom, $dtFinishTo]"
-
-    fun setEnforceMatch(matches: Boolean) {
-        partOfMatch = if (matches) MatchFilter.MATCHES_ONLY else MatchFilter.GAMES_ONLY
-    }
 }
 
 enum class MatchFilter {

src/main/kotlin/dartzee/reporting/ReportParametersGame.kt

@@ -0,0 +1,16 @@
+package dartzee.reporting
+
+import dartzee.game.GameType
+import java.sql.Timestamp
+
+data class ReportParametersGame(
+    val gameType: GameType?,
+    val gameParams: String,
+    val dtStartFrom: Timestamp?,
+    val dtStartTo: Timestamp?,
+    val unfinishedOnly: Boolean,
+    val dtFinishFrom: Timestamp?,
+    val dtFinishTo: Timestamp?,
+    val partOfMatch: MatchFilter,
+    val pendingChanges: Boolean?
+)

src/main/kotlin/dartzee/reporting/ReportParametersPlayers.kt

@@ -0,0 +1,9 @@
+package dartzee.reporting
+
+import dartzee.db.PlayerEntity
+
+data class ReportParametersPlayers(
+    val includedPlayers: Map<PlayerEntity, IncludedPlayerParameters>,
+    val excludedPlayers: List<PlayerEntity>,
+    val excludeOnlyAi: Boolean,
+)

src/main/kotlin/dartzee/reporting/ReportingSqlUtil.kt → src/main/kotlin/dartzee/reporting/ReportingUtil.kt

@@ -4,10 +4,13 @@ import dartzee.game.GameType
 import dartzee.utils.InjectedThings.mainDatabase
 import java.sql.ResultSet
 import java.sql.Timestamp
+import javax.swing.JCheckBox
+
+fun <T> grabIfSelected(checkbox: JCheckBox, getter: () -> T) =
+    if (checkbox.isSelected) getter() else null
 
-/** Refactored from ReportingResultsScreen */
 fun runReport(rp: ReportParameters?): List<ReportResultWrapper> {
-    rp ?: return listOf()
+    rp ?: return emptyList()
 
     var sql = buildBasicSqlStatement()
     sql += rp.getExtraWhereSql()

src/main/kotlin/dartzee/screen/reporting/PlayerParametersPanel.kt

@@ -7,6 +7,7 @@ import dartzee.db.MAX_PLAYERS
 import dartzee.db.PlayerEntity
 import dartzee.reporting.COMPARATOR_SCORE_UNSET
 import dartzee.reporting.IncludedPlayerParameters
+import dartzee.reporting.grabIfSelected
 import java.awt.event.ActionEvent
 import java.awt.event.ActionListener
 import javax.swing.JCheckBox
@@ -55,22 +56,12 @@ class PlayerParametersPanel : JPanel(), ActionListener {
     }
 
     fun generateParameters(): IncludedPlayerParameters {
-        val parms = IncludedPlayerParameters()
+        val finalScore = grabIfSelected(chckbxFinalScore) { spinner.value as Int }
+        val finalScoreComparator =
+            grabIfSelected(chckbxFinalScore) { comboBox.selectedItem as String }.orEmpty()
+        val finishingPosition = grabIfSelected(chckbxPosition) { getFinishingPositions() }.orEmpty()
 
-        if (chckbxFinalScore.isSelected) {
-            val finalScore = spinner.value as Int
-            val comparator = comboBox.selectedItem as String
-
-            parms.finalScore = finalScore
-            parms.finalScoreComparator = comparator
-        }
-
-        if (chckbxPosition.isSelected) {
-            val finishingPositions = getFinishingPositions()
-            parms.finishingPositions = finishingPositions
-        }
-
-        return parms
+        return IncludedPlayerParameters(finishingPosition, finalScoreComparator, finalScore)
     }
 
     private fun getFinishingPositions(): List<Int> {