Refactor entity mapping

app/src/main/java/org/koitharu/kotatsu/base/domain/MangaDataRepository.kt

@@ -2,22 +2,19 @@ package org.koitharu.kotatsu.base.domain
 
 import androidx.room.withTransaction
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.core.db.entity.*
-import org.koitharu.kotatsu.core.db.entity.MangaPrefsEntity
-import org.koitharu.kotatsu.core.db.entity.TagEntity
 import org.koitharu.kotatsu.core.prefs.ReaderMode
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaSource
 import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.parsers.util.mapToSet
 
 class MangaDataRepository(private val db: MangaDatabase) {
 
 	suspend fun savePreferences(manga: Manga, mode: ReaderMode) {
-		val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+		val tags = manga.tags.toEntities()
 		db.withTransaction {
 			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(MangaEntity.from(manga), tags)
+			db.mangaDao.upsert(manga.toEntity(), tags)
 			db.preferencesDao.upsert(
 				MangaPrefsEntity(
 					mangaId = manga.id,
@@ -42,16 +39,14 @@ class MangaDataRepository(private val db: MangaDatabase) {
 	}
 
 	suspend fun storeManga(manga: Manga) {
-		val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+		val tags = manga.tags.toEntities()
 		db.withTransaction {
 			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(MangaEntity.from(manga), tags)
+			db.mangaDao.upsert(manga.toEntity(), tags)
 		}
 	}
 
 	suspend fun findTags(source: MangaSource): Set<MangaTag> {
-		return db.tagsDao.findTags(source.name).mapToSet {
+		return db.tagsDao.findTags(source.name).toMangaTags()
-			it.toMangaTag()
-		}
 	}
 }

app/src/main/java/org/koitharu/kotatsu/core/db/entity/EntityMapping.kt

@@ -0,0 +1,76 @@
+package org.koitharu.kotatsu.core.db.entity
+
+import java.util.*
+import org.koitharu.kotatsu.core.model.TrackingLogItem
+import org.koitharu.kotatsu.parsers.model.*
+import org.koitharu.kotatsu.parsers.util.longHashCode
+import org.koitharu.kotatsu.parsers.util.mapToSet
+import org.koitharu.kotatsu.parsers.util.toTitleCase
+
+// Entity to model
+
+fun TagEntity.toMangaTag() = MangaTag(
+	key = this.key,
+	title = this.title.toTitleCase(),
+	source = MangaSource.valueOf(this.source),
+)
+
+fun Collection<TagEntity>.toMangaTags() = mapToSet(TagEntity::toMangaTag)
+
+fun MangaEntity.toManga(tags: Set<MangaTag>) = Manga(
+	id = this.id,
+	title = this.title,
+	altTitle = this.altTitle,
+	state = this.state?.let { MangaState.valueOf(it) },
+	rating = this.rating,
+	isNsfw = this.isNsfw,
+	url = this.url,
+	publicUrl = this.publicUrl,
+	coverUrl = this.coverUrl,
+	largeCoverUrl = this.largeCoverUrl,
+	author = this.author,
+	source = MangaSource.valueOf(this.source),
+	tags = tags
+)
+
+fun MangaWithTags.toManga() = manga.toManga(tags.toMangaTags())
+
+fun TrackLogWithManga.toTrackingLogItem() = TrackingLogItem(
+	id = trackLog.id,
+	chapters = trackLog.chapters.split('\n').filterNot { x -> x.isEmpty() },
+	manga = manga.toManga(tags.toMangaTags()),
+	createdAt = Date(trackLog.createdAt)
+)
+
+// Model to entity
+
+fun Manga.toEntity() = MangaEntity(
+	id = id,
+	url = url,
+	publicUrl = publicUrl,
+	source = source.name,
+	largeCoverUrl = largeCoverUrl,
+	coverUrl = coverUrl,
+	altTitle = altTitle,
+	rating = rating,
+	isNsfw = isNsfw,
+	state = state?.name,
+	title = title,
+	author = author,
+)
+
+fun MangaTag.toEntity() = TagEntity(
+	title = title,
+	key = key,
+	source = source.name,
+	id = "${key}_${source.name}".longHashCode()
+)
+
+fun Collection<MangaTag>.toEntities() = map(MangaTag::toEntity)
+
+// Other
+
+@Suppress("FunctionName")
+fun SortOrder(name: String, fallback: SortOrder): SortOrder = runCatching {
+	SortOrder.valueOf(name)
+}.getOrDefault(fallback)

app/src/main/java/org/koitharu/kotatsu/core/db/entity/MangaEntity.kt

@@ -3,10 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.model.MangaState
-import org.koitharu.kotatsu.parsers.model.MangaTag
 
 @Entity(tableName = "manga")
 class MangaEntity(
@@ -23,39 +19,4 @@ class MangaEntity(
 	@ColumnInfo(name = "state") val state: String?,
 	@ColumnInfo(name = "author") val author: String?,
 	@ColumnInfo(name = "source") val source: String
-) {
-
-	fun toManga(tags: Set<MangaTag> = emptySet()) = Manga(
-		id = this.id,
-		title = this.title,
-		altTitle = this.altTitle,
-		state = this.state?.let { MangaState.valueOf(it) },
-		rating = this.rating,
-		isNsfw = this.isNsfw,
-		url = this.url,
-		publicUrl = this.publicUrl,
-		coverUrl = this.coverUrl,
-		largeCoverUrl = this.largeCoverUrl,
-		author = this.author,
-		source = MangaSource.valueOf(this.source),
-		tags = tags
-	)
-
-	companion object {
-
-		fun from(manga: Manga) = MangaEntity(
-			id = manga.id,
-			url = manga.url,
-			publicUrl = manga.publicUrl,
-			source = manga.source.name,
-			largeCoverUrl = manga.largeCoverUrl,
-			coverUrl = manga.coverUrl,
-			altTitle = manga.altTitle,
-			rating = manga.rating,
-			isNsfw = manga.isNsfw,
-			state = manga.state?.name,
-			title = manga.title,
-			author = manga.author
 )
-	}
-}

app/src/main/java/org/koitharu/kotatsu/core/db/entity/MangaPrefsEntity.kt

@@ -6,13 +6,15 @@ import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 
 @Entity(
-	tableName = "preferences", foreignKeys = [
+	tableName = "preferences",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
 			childColumns = ["manga_id"],
 			onDelete = ForeignKey.CASCADE
-		)]
+		)
+	]
 )
 class MangaPrefsEntity(
 	@PrimaryKey(autoGenerate = false)

app/src/main/java/org/koitharu/kotatsu/core/db/entity/MangaTagsEntity.kt

@@ -5,7 +5,8 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 
 @Entity(
-	tableName = "manga_tags", primaryKeys = ["manga_id", "tag_id"], foreignKeys = [
+	tableName = "manga_tags", primaryKeys = ["manga_id", "tag_id"],
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],

app/src/main/java/org/koitharu/kotatsu/core/db/entity/MangaWithTags.kt

@@ -3,7 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.Embedded
 import androidx.room.Junction
 import androidx.room.Relation
-import org.koitharu.kotatsu.parsers.util.mapToSet
 
 class MangaWithTags(
 	@Embedded val manga: MangaEntity,
@@ -12,8 +11,5 @@ class MangaWithTags(
 		entityColumn = "tag_id",
 		associateBy = Junction(MangaTagsEntity::class)
 	)
-	val tags: List<TagEntity>
+	val tags: List<TagEntity>,
-) {
+)
-
-	fun toManga() = manga.toManga(tags.mapToSet { it.toMangaTag() })
-}

app/src/main/java/org/koitharu/kotatsu/core/db/entity/TagEntity.kt

@@ -3,10 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import org.koitharu.kotatsu.parsers.model.MangaSource
-import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.parsers.util.longHashCode
-import org.koitharu.kotatsu.parsers.util.toTitleCase
 
 @Entity(tableName = "tags")
 class TagEntity(
@@ -15,21 +11,4 @@ class TagEntity(
 	@ColumnInfo(name = "title") val title: String,
 	@ColumnInfo(name = "key") val key: String,
 	@ColumnInfo(name = "source") val source: String
-) {
-
-	fun toMangaTag() = MangaTag(
-		key = this.key,
-		title = this.title.toTitleCase(),
-		source = MangaSource.valueOf(this.source)
-	)
-
-	companion object {
-
-		fun fromMangaTag(tag: MangaTag) = TagEntity(
-			title = tag.title,
-			key = tag.key,
-			source = tag.source.name,
-			id = "${tag.key}_${tag.source.name}".longHashCode()
 )
-	}
-}

app/src/main/java/org/koitharu/kotatsu/core/db/entity/TrackEntity.kt

@@ -6,7 +6,8 @@ import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 
 @Entity(
-	tableName = "tracks", foreignKeys = [
+	tableName = "tracks",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],

app/src/main/java/org/koitharu/kotatsu/core/db/entity/TrackLogEntity.kt

@@ -6,7 +6,8 @@ import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 
 @Entity(
-	tableName = "track_logs", foreignKeys = [
+	tableName = "track_logs",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
@@ -20,5 +21,5 @@ class TrackLogEntity(
 	@ColumnInfo(name = "id") val id: Long = 0L,
 	@ColumnInfo(name = "manga_id", index = true) val mangaId: Long,
 	@ColumnInfo(name = "chapters") val chapters: String,
-	@ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis()
+	@ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis(),
 )

app/src/main/java/org/koitharu/kotatsu/core/db/entity/TrackLogWithManga.kt

@@ -3,10 +3,6 @@ package org.koitharu.kotatsu.core.db.entity
 import androidx.room.Embedded
 import androidx.room.Junction
 import androidx.room.Relation
-import java.util.*
-import org.koitharu.kotatsu.core.model.TrackingLogItem
-import org.koitharu.kotatsu.parsers.util.mapToSet
-import org.koitharu.kotatsu.utils.ext.mapToSet
 
 class TrackLogWithManga(
 	@Embedded val trackLog: TrackLogEntity,
@@ -20,13 +16,5 @@ class TrackLogWithManga(
 		entityColumn = "tag_id",
 		associateBy = Junction(MangaTagsEntity::class)
 	)
-	val tags: List<TagEntity>
+	val tags: List<TagEntity>,
-) {
-
-	fun toTrackingLogItem() = TrackingLogItem(
-		id = trackLog.id,
-		chapters = trackLog.chapters.split('\n').filterNot { x -> x.isEmpty() },
-		manga = manga.toManga(tags.mapToSet { x -> x.toMangaTag() }),
-		createdAt = Date(trackLog.createdAt)
 )
-}

app/src/main/java/org/koitharu/kotatsu/favourites/data/EntityMapping.kt

@@ -0,0 +1,14 @@
+package org.koitharu.kotatsu.favourites.data
+
+import java.util.*
+import org.koitharu.kotatsu.core.db.entity.SortOrder
+import org.koitharu.kotatsu.core.model.FavouriteCategory
+import org.koitharu.kotatsu.parsers.model.SortOrder
+
+fun FavouriteCategoryEntity.toFavouriteCategory(id: Long = categoryId.toLong()) = FavouriteCategory(
+	id = id,
+	title = title,
+	sortKey = sortKey,
+	order = SortOrder(order, SortOrder.NEWEST),
+	createdAt = Date(createdAt),
+)

app/src/main/java/org/koitharu/kotatsu/favourites/data/FavouriteCategoryEntity.kt

@@ -3,9 +3,6 @@ package org.koitharu.kotatsu.favourites.data
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import org.koitharu.kotatsu.core.model.FavouriteCategory
-import org.koitharu.kotatsu.parsers.model.SortOrder
-import java.util.*
 
 @Entity(tableName = "favourite_categories")
 class FavouriteCategoryEntity(
@@ -15,13 +12,4 @@ class FavouriteCategoryEntity(
 	@ColumnInfo(name = "sort_key") val sortKey: Int,
 	@ColumnInfo(name = "title") val title: String,
 	@ColumnInfo(name = "order") val order: String,
-) {
-
-	fun toFavouriteCategory(id: Long? = null) = FavouriteCategory(
-		id = id ?: categoryId.toLong(),
-		title = title,
-		sortKey = sortKey,
-		order = SortOrder.values().find { x -> x.name == order } ?: SortOrder.NEWEST,
-		createdAt = Date(createdAt),
 )
-}

app/src/main/java/org/koitharu/kotatsu/favourites/domain/FavouritesRepository.kt

@@ -6,36 +6,35 @@ import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.core.db.entity.*
-import org.koitharu.kotatsu.core.db.entity.TagEntity
 import org.koitharu.kotatsu.core.model.FavouriteCategory
 import org.koitharu.kotatsu.favourites.data.FavouriteCategoryEntity
 import org.koitharu.kotatsu.favourites.data.FavouriteEntity
+import org.koitharu.kotatsu.favourites.data.toFavouriteCategory
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.SortOrder
-import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.utils.ext.mapItems
 
 class FavouritesRepository(private val db: MangaDatabase) {
 
 	suspend fun getAllManga(): List<Manga> {
 		val entities = db.favouritesDao.findAll()
-		return entities.map { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+		return entities.map { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	fun observeAll(order: SortOrder): Flow<List<Manga>> {
 		return db.favouritesDao.observeAll(order)
-			.mapItems { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+			.mapItems { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	suspend fun getManga(categoryId: Long): List<Manga> {
 		val entities = db.favouritesDao.findAll(categoryId)
-		return entities.map { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+		return entities.map { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	fun observeAll(categoryId: Long, order: SortOrder): Flow<List<Manga>> {
 		return db.favouritesDao.observeAll(categoryId, order)
-			.mapItems { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+			.mapItems { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	fun observeAll(categoryId: Long): Flow<List<Manga>> {
@@ -95,9 +94,9 @@ class FavouritesRepository(private val db: MangaDatabase) {
 	suspend fun addToCategory(categoryId: Long, mangas: Collection<Manga>) {
 		db.withTransaction {
 			for (manga in mangas) {
-				val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+				val tags = manga.tags.toEntities()
 				db.tagsDao.upsert(tags)
-				db.mangaDao.upsert(MangaEntity.from(manga), tags)
+				db.mangaDao.upsert(manga.toEntity(), tags)
 				val entity = FavouriteEntity(manga.id, categoryId, System.currentTimeMillis())
 				db.favouritesDao.insert(entity)
 			}
@@ -122,7 +121,7 @@ class FavouritesRepository(private val db: MangaDatabase) {
 
 	private fun observeOrder(categoryId: Long): Flow<SortOrder> {
 		return db.favouriteCategoriesDao.observe(categoryId)
-			.map { x -> SortOrder.values().find { it.name == x.order } ?: SortOrder.NEWEST }
+			.map { x -> SortOrder(x.order, SortOrder.NEWEST) }
 			.distinctUntilChanged()
 	}
 }

app/src/main/java/org/koitharu/kotatsu/history/data/EntityMapping.kt

@@ -0,0 +1,12 @@
+package org.koitharu.kotatsu.history.data
+
+import java.util.*
+import org.koitharu.kotatsu.core.model.MangaHistory
+
+fun HistoryEntity.toMangaHistory() = MangaHistory(
+	createdAt = Date(createdAt),
+	updatedAt = Date(updatedAt),
+	chapterId = chapterId,
+	page = page,
+	scroll = scroll.toInt()
+)

app/src/main/java/org/koitharu/kotatsu/history/data/HistoryEntity.kt

@@ -5,11 +5,10 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.PrimaryKey
 import org.koitharu.kotatsu.core.db.entity.MangaEntity
-import org.koitharu.kotatsu.core.model.MangaHistory
-import java.util.*
 
 @Entity(
-	tableName = "history", foreignKeys = [
+	tableName = "history",
+	foreignKeys = [
 		ForeignKey(
 			entity = MangaEntity::class,
 			parentColumns = ["manga_id"],
@@ -26,13 +25,4 @@ class HistoryEntity(
 	@ColumnInfo(name = "chapter_id") val chapterId: Long,
 	@ColumnInfo(name = "page") val page: Int,
 	@ColumnInfo(name = "scroll") val scroll: Float,
-) {
-
-	fun toMangaHistory() = MangaHistory(
-		createdAt = Date(createdAt),
-		updatedAt = Date(updatedAt),
-		chapterId = chapterId,
-		page = page,
-		scroll = scroll.toInt()
 )
-}

app/src/main/java/org/koitharu/kotatsu/history/data/HistoryWithManga.kt

@@ -19,5 +19,5 @@ class HistoryWithManga(
 		entityColumn = "tag_id",
 		associateBy = Junction(MangaTagsEntity::class)
 	)
-	val tags: List<TagEntity>
+	val tags: List<TagEntity>,
 )

app/src/main/java/org/koitharu/kotatsu/history/domain/HistoryRepository.kt

@@ -5,14 +5,13 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.core.db.entity.*
-import org.koitharu.kotatsu.core.db.entity.TagEntity
 import org.koitharu.kotatsu.core.model.MangaHistory
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.history.data.HistoryEntity
+import org.koitharu.kotatsu.history.data.toMangaHistory
 import org.koitharu.kotatsu.parsers.model.Manga
 import org.koitharu.kotatsu.parsers.model.MangaTag
-import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.tracker.domain.TrackingRepository
 import org.koitharu.kotatsu.utils.ext.mapItems
 
@@ -24,25 +23,25 @@ class HistoryRepository(
 
 	suspend fun getList(offset: Int, limit: Int = 20): List<Manga> {
 		val entities = db.historyDao.findAll(offset, limit)
-		return entities.map { it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)) }
+		return entities.map { it.manga.toManga(it.tags.toMangaTags()) }
 	}
 
 	suspend fun getLastOrNull(): Manga? {
 		val entity = db.historyDao.findAll(0, 1).firstOrNull() ?: return null
-		return entity.manga.toManga(entity.tags.mapToSet { it.toMangaTag() })
+		return entity.manga.toManga(entity.tags.toMangaTags())
 	}
 
 	fun observeAll(): Flow<List<Manga>> {
 		return db.historyDao.observeAll().mapItems {
-			it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag))
+			it.manga.toManga(it.tags.toMangaTags())
 		}
 	}
 
 	fun observeAllWithHistory(): Flow<List<MangaWithHistory>> {
 		return db.historyDao.observeAll().mapItems {
 			MangaWithHistory(
-				it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag)),
+				it.manga.toManga(it.tags.toMangaTags()),
-				it.history.toMangaHistory()
+				it.history.toMangaHistory(),
 			)
 		}
 	}
@@ -63,10 +62,10 @@ class HistoryRepository(
 		if (manga.isNsfw && settings.isHistoryExcludeNsfw) {
 			return
 		}
-		val tags = manga.tags.map(TagEntity.Companion::fromMangaTag)
+		val tags = manga.tags.toEntities()
 		db.withTransaction {
 			db.tagsDao.upsert(tags)
-			db.mangaDao.upsert(MangaEntity.from(manga), tags)
+			db.mangaDao.upsert(manga.toEntity(), tags)
 			db.historyDao.upsert(
 				HistoryEntity(
 					mangaId = manga.id,
@@ -74,7 +73,7 @@ class HistoryRepository(
 					updatedAt = System.currentTimeMillis(),
 					chapterId = chapterId,
 					page = page,
-					scroll = scroll.toFloat() // we migrate to int, but decide to not update database
+					scroll = scroll.toFloat(), // we migrate to int, but decide to not update database
 				)
 			)
 			trackingRepository.upsert(manga)
@@ -106,7 +105,7 @@ class HistoryRepository(
 	 * Useful for replacing saved manga on deleting it with remove source
 	 */
 	suspend fun deleteOrSwap(manga: Manga, alternative: Manga?) {
-		if (alternative == null || db.mangaDao.update(MangaEntity.from(alternative)) <= 0) {
+		if (alternative == null || db.mangaDao.update(alternative.toEntity()) <= 0) {
 			db.historyDao.delete(manga.id)
 		}
 	}

app/src/main/java/org/koitharu/kotatsu/search/domain/MangaSearchRepository.kt

@@ -10,6 +10,8 @@ import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.withContext
 import org.koitharu.kotatsu.core.db.MangaDatabase
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.db.entity.toMangaTag
 import org.koitharu.kotatsu.core.parser.MangaRepository
 import org.koitharu.kotatsu.core.prefs.AppSettings
 import org.koitharu.kotatsu.parsers.model.Manga

app/src/main/java/org/koitharu/kotatsu/suggestions/data/SuggestionWithManga.kt

@@ -19,5 +19,5 @@ data class SuggestionWithManga(
 		entityColumn = "tag_id",
 		associateBy = Junction(MangaTagsEntity::class)
 	)
-	val tags: List<TagEntity>
+	val tags: List<TagEntity>,
 )

app/src/main/java/org/koitharu/kotatsu/suggestions/domain/SuggestionRepository.kt

@@ -3,10 +3,11 @@ package org.koitharu.kotatsu.suggestions.domain
 import androidx.room.withTransaction
 import kotlinx.coroutines.flow.Flow
 import org.koitharu.kotatsu.core.db.MangaDatabase
-import org.koitharu.kotatsu.core.db.entity.MangaEntity
+import org.koitharu.kotatsu.core.db.entity.toEntities
-import org.koitharu.kotatsu.core.db.entity.TagEntity
+import org.koitharu.kotatsu.core.db.entity.toEntity
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.db.entity.toMangaTags
 import org.koitharu.kotatsu.parsers.model.Manga
-import org.koitharu.kotatsu.parsers.util.mapToSet
 import org.koitharu.kotatsu.suggestions.data.SuggestionEntity
 import org.koitharu.kotatsu.utils.ext.mapItems
 
@@ -16,7 +17,7 @@ class SuggestionRepository(
 
 	fun observeAll(): Flow<List<Manga>> {
 		return db.suggestionDao.observeAll().mapItems {
-			it.manga.toManga(it.tags.mapToSet(TagEntity::toMangaTag))
+			it.manga.toManga(it.tags.toMangaTags())
 		}
 	}
 
@@ -32,9 +33,9 @@ class SuggestionRepository(
 		db.withTransaction {
 			db.suggestionDao.deleteAll()
 			suggestions.forEach { x ->
-				val tags = x.manga.tags.map(TagEntity.Companion::fromMangaTag)
+				val tags = x.manga.tags.toEntities()
 				db.tagsDao.upsert(tags)
-				db.mangaDao.upsert(MangaEntity.from(x.manga), tags)
+				db.mangaDao.upsert(x.manga.toEntity(), tags)
 				db.suggestionDao.upsert(
 					SuggestionEntity(
 						mangaId = x.manga.id,

app/src/main/java/org/koitharu/kotatsu/tracker/domain/TrackingRepository.kt

@@ -4,6 +4,8 @@ import androidx.room.withTransaction
 import org.koitharu.kotatsu.core.db.MangaDatabase
 import org.koitharu.kotatsu.core.db.entity.TrackEntity
 import org.koitharu.kotatsu.core.db.entity.TrackLogEntity
+import org.koitharu.kotatsu.core.db.entity.toManga
+import org.koitharu.kotatsu.core.db.entity.toTrackingLogItem
 import org.koitharu.kotatsu.core.model.MangaTracking
 import org.koitharu.kotatsu.core.model.TrackingLogItem
 import org.koitharu.kotatsu.parsers.model.Manga
@@ -22,10 +24,10 @@ class TrackingRepository(
 	suspend fun getAllTracks(useFavourites: Boolean, useHistory: Boolean): List<MangaTracking> {
 		val mangaList = ArrayList<Manga>()
 		if (useFavourites) {
-			db.favouritesDao.findAllManga().mapTo(mangaList) { it.toManga() }
+			db.favouritesDao.findAllManga().mapTo(mangaList) { it.toManga(emptySet()) }
 		}
 		if (useHistory) {
-			db.historyDao.findAllManga().mapTo(mangaList) { it.toManga() }
+			db.historyDao.findAllManga().mapTo(mangaList) { it.toManga(emptySet()) }
 		}
 		val tracks = db.tracksDao.findAll().groupBy { it.mangaId }
 		return mangaList