Refactor/interface diff result

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/common/IDiffResult.kt

@@ -0,0 +1,9 @@
+package com.github.attacktive.troubleshootereditor.domain.common
+
+interface IDiffResult<T> {
+	val id: T
+
+	fun insert(propertyIndex: Int, propertyValue: String)
+	fun update(propertyIndex: Int, propertyValue: String)
+	fun delete(propertyIndex: Int)
+}

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/common/Properties.kt

@@ -1,14 +1,16 @@
 package com.github.attacktive.troubleshootereditor.domain.common
 
 import java.util.function.Predicate
+import com.github.attacktive.troubleshootereditor.extension.logger
 
-data class Properties(private val list: List<Property> = mutableListOf()) {
+open class Properties(private val list: List<Property> = mutableListOf()) {
 	constructor(map: Map<String, String>): this(map.map { Property(it.toPair()) }.toMutableList())
 
+	private val logger by logger()
+
 	fun containsKey(key: String) = keys().contains(key)
 	fun containsKeyThat(predicate: Predicate<String>) = keys().any { predicate.test(it) }
 
-	fun forEach(action: (Property) -> Unit) = list.forEach(action)
 	fun toMap() = list.associate { it.key to it.value }
 
 	fun diff(those: Properties): Properties {
@@ -41,6 +43,22 @@ data class Properties(private val list: List<Property> = mutableListOf()) {
 		return Properties((withThese + withThose).toMutableList())
 	}
 
+	fun <T> applyPropertyChanges(diffResult: IDiffResult<T>, propertyMasterLookup: Map<String, Int>) {
+		for (property in list) {
+			val propertyIndex = propertyMasterLookup[property.key]
+			if (propertyIndex == null) {
+				logger.warn("Failed to find item property master index for \"${property.key}\"; ignoring. 😞")
+			} else {
+				when (property.diffType) {
+					DiffType.NONE -> {}
+					DiffType.ADDED -> diffResult.insert(propertyIndex, property.value)
+					DiffType.MODIFIED -> diffResult.update(propertyIndex, property.value)
+					DiffType.REMOVED -> diffResult.delete(propertyIndex)
+				}
+			}
+		}
+	}
+
 	private fun keys() = list.map { it.key }.toSet()
 
 	private fun findByKey(key: String) = list.find { it.key == key }

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/company/Company.kt

@@ -1,10 +1,17 @@
 package com.github.attacktive.troubleshootereditor.domain.company
 
 import com.fasterxml.jackson.annotation.JsonGetter
+import com.github.attacktive.troubleshootereditor.domain.common.IDiffResult
 import com.github.attacktive.troubleshootereditor.domain.common.Properties
+import com.github.attacktive.troubleshootereditor.domain.company.table.CompanyProperties
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.update
 
 data class Company(val id: Int, val name: String, val vill: Long, val properties: Properties) {
-	constructor(id: Int, name: String, vill:Long, properties: Map<String, String>): this(id, name, vill, Properties(properties))
+	constructor(id: Int, name: String, vill: Long, properties: Map<String, String>): this(id, name, vill, Properties(properties))
 
 	@JsonGetter(value = "properties")
 	fun properties() = properties.toMap().toSortedMap()
@@ -17,5 +24,25 @@ data class Company(val id: Int, val name: String, val vill: Long, val properties
 		return DiffResult(id, name, vill, properties)
 	}
 
-	data class DiffResult(val id: Int, val name: String?, val vill: Long?, val properties: Properties)
+	data class DiffResult(override val id: Int, val name: String?, val vill: Long?, val properties: Properties): IDiffResult<Int> {
+		override fun insert(propertyIndex: Int, propertyValue: String) {
+			CompanyProperties.insert {
+				it[companyId] = id
+				it[masterIndex] = propertyIndex
+				it[cpValue] = propertyValue
+			}
+		}
+
+		override fun update(propertyIndex: Int, propertyValue: String) {
+			CompanyProperties.update({ (CompanyProperties.companyId eq id) and (CompanyProperties.masterIndex eq propertyIndex) }) {
+				it[cpValue] = propertyValue
+			}
+		}
+
+		override fun delete(propertyIndex: Int) {
+			CompanyProperties.deleteWhere {
+				(companyId eq id) and (masterIndex eq propertyIndex)
+			}
+		}
+	}
 }

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/company/CompanyObject.kt

@@ -1,26 +1,18 @@
 package com.github.attacktive.troubleshootereditor.domain.company
 
-import com.github.attacktive.troubleshootereditor.domain.common.DiffType
 import com.github.attacktive.troubleshootereditor.domain.common.Property
 import com.github.attacktive.troubleshootereditor.domain.company.table.Companies
 import com.github.attacktive.troubleshootereditor.domain.company.table.CompanyProperties
 import com.github.attacktive.troubleshootereditor.domain.company.table.CompanyPropertyMaster
-import com.github.attacktive.troubleshootereditor.extension.logger
 import com.github.attacktive.troubleshootereditor.extension.toProperties
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.SortOrder
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.StdOutSqlLogger
 import org.jetbrains.exposed.sql.addLogger
-import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.deleteWhere
-import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 
 object CompanyObject {
-	private val logger by logger()
-
 	fun selectCompany(url: String): Company {
 		Database.connect(url)
 
@@ -66,28 +58,7 @@ object CompanyObject {
 				}
 			}
 
-			diffResult.properties
-				.forEach { property ->
-					val propertyIndex = companyMasterLookup[property.key]
-					if (propertyIndex == null) {
-						logger.warn("Failed to find property Company master index for \"${property.key}\"; ignoring. 😞")
-					} else {
-						when (property.diffType) {
-							DiffType.NONE -> {}
-							DiffType.ADDED -> CompanyProperties.insert {
-								it[companyId] = diffResult.id
-								it[masterIndex] = propertyIndex
-								it[cpValue] = property.value
-							}
-							DiffType.MODIFIED -> CompanyProperties.update({ (CompanyProperties.companyId eq diffResult.id) and (CompanyProperties.masterIndex eq propertyIndex) }) {
-								it[cpValue] = property.value
-							}
-							DiffType.REMOVED -> CompanyProperties.deleteWhere {
-								(companyId eq diffResult.id) and (masterIndex eq propertyIndex)
-							}
-						}
-					}
-				}
+			diffResult.properties.applyPropertyChanges(diffResult, companyMasterLookup)
 		}
 	}
 

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/item/EquipmentPosition.kt

@@ -1,5 +1,6 @@
 package com.github.attacktive.troubleshootereditor.domain.item
 
+@Suppress("unused")
 enum class EquipmentPosition(val value: String, val options: List<Pair<ItemOption, Int>>?) {
 	WEAPON("Weapon", ItemOption.forWeapons),
 	BODY("Body", ItemOption.forBodies),

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/item/Item.kt

@@ -2,7 +2,14 @@ package com.github.attacktive.troubleshootereditor.domain.item
 
 import com.fasterxml.jackson.annotation.JsonGetter
 import com.github.attacktive.troubleshootereditor.domain.common.Diffable
+import com.github.attacktive.troubleshootereditor.domain.common.IDiffResult
 import com.github.attacktive.troubleshootereditor.domain.common.Properties
+import com.github.attacktive.troubleshootereditor.domain.item.table.ItemProperties
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.update
 
 data class Item(val id: Long, val type: String, val count: Long, val status: String, val properties: Properties, var equipmentPosition: EquipmentPosition? = null): Diffable<Item, Long, Item.DiffResult> {
 	constructor(id: Long, type: String, count: Long, status: String, properties: Map<String, String>, equipmentPosition: EquipmentPosition? = null): this(id, type, count, status, Properties(properties), equipmentPosition)
@@ -29,5 +36,25 @@ data class Item(val id: Long, val type: String, val count: Long, val status: Str
 		return properties.containsKeyThat { it.matches(Regex("Option/.+", RegexOption.IGNORE_CASE)) }
 	}
 
-	data class DiffResult(val id: Long, val type: String?, val count: Long?, val status: String?, val properties: Properties)
+	data class DiffResult(override val id: Long, val type: String?, val count: Long?, val status: String?, val properties: Properties): IDiffResult<Long> {
+		override fun insert(propertyIndex: Int, propertyValue: String) {
+			ItemProperties.insert {
+				it[itemId] = id
+				it[masterIndex] = propertyIndex
+				it[value] = propertyValue
+			}
+		}
+
+		override fun update(propertyIndex: Int, propertyValue: String) {
+			ItemProperties.update({ (ItemProperties.itemId eq id) and (ItemProperties.masterIndex eq propertyIndex) }) {
+				it[value] = propertyValue
+			}
+		}
+
+		override fun delete(propertyIndex: Int) {
+			ItemProperties.deleteWhere {
+				(itemId eq id) and (masterIndex eq propertyIndex)
+			}
+		}
+	}
 }

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/item/ItemObject.kt

@@ -1,6 +1,5 @@
 package com.github.attacktive.troubleshootereditor.domain.item
 
-import com.github.attacktive.troubleshootereditor.domain.common.DiffType
 import com.github.attacktive.troubleshootereditor.domain.common.Property
 import com.github.attacktive.troubleshootereditor.domain.item.table.ItemEquippedInfos
 import com.github.attacktive.troubleshootereditor.domain.item.table.ItemProperties
@@ -12,12 +11,9 @@ import com.github.attacktive.troubleshootereditor.extension.getDiffResults
 import com.github.attacktive.troubleshootereditor.extension.logger
 import com.github.attacktive.troubleshootereditor.extension.toProperties
 import org.jetbrains.exposed.sql.Database
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.StdOutSqlLogger
 import org.jetbrains.exposed.sql.addLogger
 import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.deleteWhere
-import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 
@@ -116,29 +112,8 @@ object ItemObject {
 					}
 				}
 
-				itemDiff.properties
-					.forEach { property ->
-						val propertyIndex = itemPropertyMasterLookup[property.key]
-						if (propertyIndex == null) {
-							logger.warn("Failed to find item property master index for \"${property.key}\"; ignoring. 😞")
-						} else {
-							when (property.diffType) {
-								DiffType.NONE -> {}
-								DiffType.ADDED -> ItemProperties.insert {
-									it[itemId] = itemDiff.id
-									it[masterIndex] = propertyIndex
-									it[value] = property.value
-								}
-								DiffType.MODIFIED -> ItemProperties.update({ (ItemProperties.itemId eq itemDiff.id) and (ItemProperties.masterIndex eq propertyIndex) }) {
-									it[value] = property.value
-								}
-								DiffType.REMOVED -> ItemProperties.deleteWhere {
-									(itemId eq itemDiff.id) and (masterIndex eq propertyIndex)
-								}
-							}
-						}
-					}
-				}
+				itemDiff.properties.applyPropertyChanges(itemDiff, itemPropertyMasterLookup)
+			}
 		}
 	}
 

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/roster/Roster.kt

@@ -1,7 +1,14 @@
 package com.github.attacktive.troubleshootereditor.domain.roster
 
 import com.github.attacktive.troubleshootereditor.domain.common.Diffable
+import com.github.attacktive.troubleshootereditor.domain.common.IDiffResult
 import com.github.attacktive.troubleshootereditor.domain.common.Properties
+import com.github.attacktive.troubleshootereditor.domain.roster.table.RosterProperties
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.deleteWhere
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.update
 
 data class Roster(val id: Long, val name: String, val `class`: String, val level: Long, val exp: Long, val properties: Properties): Diffable<Roster, Long, Roster.DiffResult> {
 	override fun getId() = id
@@ -16,5 +23,25 @@ data class Roster(val id: Long, val name: String, val `class`: String, val level
 		return DiffResult(id, name, `class`, level, exp, properties)
 	}
 
-	data class DiffResult(val id: Long, val name: String?, val `class`: String?, val level: Long?, val exp: Long?, val properties: Properties)
+	data class DiffResult(override val id: Long, val name: String?, val `class`: String?, val level: Long?, val exp: Long?, val properties: Properties): IDiffResult<Long> {
+		override fun insert(propertyIndex: Int, propertyValue: String) {
+			RosterProperties.insert {
+				it[rosterId] = id
+				it[masterIndex] = propertyIndex
+				it[value] = propertyValue
+			}
+		}
+
+		override fun update(propertyIndex: Int, propertyValue: String) {
+			RosterProperties.update({ (RosterProperties.rosterId eq id) and (RosterProperties.masterIndex eq propertyIndex) }) {
+				it[value] = propertyValue
+			}
+		}
+
+		override fun delete(propertyIndex: Int) {
+			RosterProperties.deleteWhere {
+				(rosterId eq id) and (masterIndex eq propertyIndex)
+			}
+		}
+	}
 }

src/main/kotlin/com/github/attacktive/troubleshootereditor/domain/roster/RosterObject.kt

@@ -1,27 +1,19 @@
 package com.github.attacktive.troubleshootereditor.domain.roster
 
-import com.github.attacktive.troubleshootereditor.domain.common.DiffType
 import com.github.attacktive.troubleshootereditor.domain.common.Property
-import com.github.attacktive.troubleshootereditor.domain.item.table.ItemProperties
 import com.github.attacktive.troubleshootereditor.domain.roster.table.RosterProperties
 import com.github.attacktive.troubleshootereditor.domain.roster.table.RosterPropertyMaster
 import com.github.attacktive.troubleshootereditor.domain.roster.table.Rosters
 import com.github.attacktive.troubleshootereditor.extension.getDiffResults
-import com.github.attacktive.troubleshootereditor.extension.logger
 import com.github.attacktive.troubleshootereditor.extension.toProperties
 import org.jetbrains.exposed.sql.Database
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 import org.jetbrains.exposed.sql.StdOutSqlLogger
 import org.jetbrains.exposed.sql.addLogger
 import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.deleteWhere
-import org.jetbrains.exposed.sql.insert
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.jetbrains.exposed.sql.update
 
 object RosterObject {
-	private val logger by logger()
-
 	fun selectRosters(url: String): List<Roster> {
 		Database.connect(url)
 
@@ -84,28 +76,7 @@ object RosterObject {
 					}
 				}
 
-				rosterDiff.properties
-					.forEach { property ->
-						val propertyIndex = rosterPropertyMasterLookup[property.key]
-						if (propertyIndex == null) {
-							logger.warn("Failed to find roster property master index for \"${property.key}\"; ignoring. 😞")
-						} else {
-							when (property.diffType) {
-								DiffType.NONE -> {}
-								DiffType.ADDED -> ItemProperties.insert {
-									it[itemId] = rosterDiff.id
-									it[masterIndex] = propertyIndex
-									it[value] = property.value
-								}
-								DiffType.MODIFIED -> ItemProperties.update({ (ItemProperties.itemId eq rosterDiff.id) and (ItemProperties.masterIndex eq propertyIndex) }) {
-									it[value] = property.value
-								}
-								DiffType.REMOVED -> ItemProperties.deleteWhere {
-									(itemId eq rosterDiff.id) and (masterIndex eq propertyIndex)
-								}
-							}
-						}
-					}
+				rosterDiff.properties.applyPropertyChanges(rosterDiff, rosterPropertyMasterLookup)
 			}
 		}
 	}