Use sqldelight for direct db calls in MangaPresenter (#7366)

app/src/main/java/eu/kanade/domain/DomainModule.kt

@@ -15,6 +15,7 @@ import eu.kanade.domain.category.repository.CategoryRepository
 import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
 import eu.kanade.domain.chapter.interactor.ShouldUpdateDbChapter
 import eu.kanade.domain.chapter.interactor.SyncChaptersWithSource
+import eu.kanade.domain.chapter.interactor.SyncChaptersWithTrackServiceTwoWay
 import eu.kanade.domain.chapter.interactor.UpdateChapter
 import eu.kanade.domain.chapter.repository.ChapterRepository
 import eu.kanade.domain.extension.interactor.GetExtensionLanguages
@@ -47,6 +48,7 @@ import eu.kanade.domain.source.interactor.ToggleSource
 import eu.kanade.domain.source.interactor.ToggleSourcePin
 import eu.kanade.domain.source.interactor.UpsertSourceData
 import eu.kanade.domain.source.repository.SourceRepository
+import eu.kanade.domain.track.interactor.DeleteTrack
 import eu.kanade.domain.track.interactor.GetTracks
 import eu.kanade.domain.track.interactor.InsertTrack
 import eu.kanade.domain.track.repository.TrackRepository
@@ -77,6 +79,7 @@ class DomainModule : InjektModule {
         addFactory { MoveMangaToCategories(get()) }
 
         addSingletonFactory<TrackRepository> { TrackRepositoryImpl(get()) }
+        addFactory { DeleteTrack(get()) }
         addFactory { GetTracks(get()) }
         addFactory { InsertTrack(get()) }
 
@@ -85,6 +88,7 @@ class DomainModule : InjektModule {
         addFactory { UpdateChapter(get()) }
         addFactory { ShouldUpdateDbChapter() }
         addFactory { SyncChaptersWithSource(get(), get(), get(), get()) }
+        addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }
 
         addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
         addFactory { DeleteHistoryTable(get()) }

app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithTrackServiceTwoWay.kt

@@ -0,0 +1,41 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.chapter.model.toChapterUpdate
+import eu.kanade.domain.track.interactor.InsertTrack
+import eu.kanade.domain.track.model.Track
+import eu.kanade.domain.track.model.toDbTrack
+import eu.kanade.tachiyomi.data.track.TrackService
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class SyncChaptersWithTrackServiceTwoWay(
+    private val updateChapter: UpdateChapter = Injekt.get(),
+    private val insertTrack: InsertTrack = Injekt.get(),
+) {
+
+    suspend fun await(
+        chapters: List<Chapter>,
+        remoteTrack: Track,
+        service: TrackService,
+    ) {
+        val sortedChapters = chapters.sortedBy { it.chapterNumber }
+        val chapterUpdates = sortedChapters
+            .filter { chapter -> chapter.chapterNumber <= remoteTrack.lastChapterRead && !chapter.read }
+            .map { it.copy(read = true).toChapterUpdate() }
+
+        // only take into account continuous reading
+        val localLastRead = sortedChapters.takeWhile { it.read }.lastOrNull()?.chapterNumber ?: 0F
+        val updatedTrack = remoteTrack.copy(lastChapterRead = localLastRead.toDouble())
+
+        try {
+            service.update(updatedTrack.toDbTrack())
+            updateChapter.awaitAll(chapterUpdates)
+            insertTrack.await(updatedTrack)
+        } catch (e: Throwable) {
+            logcat(LogPriority.WARN, e)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/manga/interactor/SetMangaChapterFlags.kt

@@ -4,7 +4,9 @@ import eu.kanade.domain.manga.model.Manga
 import eu.kanade.domain.manga.model.MangaUpdate
 import eu.kanade.domain.manga.repository.MangaRepository
 
-class SetMangaChapterFlags(private val mangaRepository: MangaRepository) {
+class SetMangaChapterFlags(
+    private val mangaRepository: MangaRepository,
+) {
 
     suspend fun awaitSetDownloadedFilter(manga: Manga, flag: Long): Boolean {
         return mangaRepository.update(

app/src/main/java/eu/kanade/domain/manga/model/Manga.kt

@@ -1,5 +1,6 @@
 package eu.kanade.domain.manga.model
 
+import eu.kanade.data.listOfStringsAdapter
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.source.LocalSource
@@ -143,7 +144,7 @@ fun TriStateFilter.toTriStateGroupState(): ExtendedNavigationView.Item.TriStateG
 }
 
 // TODO: Remove when all deps are migrated
-fun Manga.toDbManga(): DbManga = DbManga.create(url, title, source).also {
+fun Manga.toDbManga(): DbManga = DbManga.create(source).also {
     it.id = id
     it.favorite = favorite
     it.last_update = lastUpdate
@@ -151,7 +152,15 @@ fun Manga.toDbManga(): DbManga = DbManga.create(url, title, source).also {
     it.viewer_flags = viewerFlags.toInt()
     it.chapter_flags = chapterFlags.toInt()
     it.cover_last_modified = coverLastModified
+    it.url = url
+    it.title = title
+    it.artist = artist
+    it.author = author
+    it.description = description
+    it.genre = genre?.let(listOfStringsAdapter::encode)
+    it.status = status.toInt()
     it.thumbnail_url = thumbnailUrl
+    it.initialized = initialized
 }
 
 fun Manga.toMangaInfo(): MangaInfo = MangaInfo(

app/src/main/java/eu/kanade/domain/track/interactor/DeleteTrack.kt

@@ -0,0 +1,18 @@
+package eu.kanade.domain.track.interactor
+
+import eu.kanade.domain.track.repository.TrackRepository
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class DeleteTrack(
+    private val trackRepository: TrackRepository,
+) {
+
+    suspend fun await(mangaId: Long, syncId: Long) {
+        try {
+            trackRepository.delete(mangaId, syncId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/track/interactor/GetTracks.kt

@@ -3,6 +3,7 @@ package eu.kanade.domain.track.interactor
 import eu.kanade.domain.track.model.Track
 import eu.kanade.domain.track.repository.TrackRepository
 import eu.kanade.tachiyomi.util.system.logcat
+import kotlinx.coroutines.flow.Flow
 import logcat.LogPriority
 
 class GetTracks(
@@ -17,4 +18,8 @@ class GetTracks(
             emptyList()
         }
     }
+
+    suspend fun subscribe(mangaId: Long): Flow<List<Track>> {
+        return trackRepository.subscribeTracksByMangaId(mangaId)
+    }
 }

app/src/main/java/eu/kanade/domain/track/interactor/InsertTrack.kt

@@ -9,6 +9,14 @@ class InsertTrack(
     private val trackRepository: TrackRepository,
 ) {
 
+    suspend fun await(track: Track) {
+        try {
+            trackRepository.insert(track)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+
     suspend fun awaitAll(tracks: List<Track>) {
         try {
             trackRepository.insertAll(tracks)

app/src/main/java/eu/kanade/domain/track/model/Track.kt

@@ -1,5 +1,7 @@
 package eu.kanade.domain.track.model
 
+import eu.kanade.tachiyomi.data.database.models.Track as DbTrack
+
 data class Track(
     val id: Long,
     val mangaId: Long,
@@ -25,3 +27,37 @@ data class Track(
         )
     }
 }
+
+fun Track.toDbTrack(): DbTrack = DbTrack.create(syncId.toInt()).also {
+    it.id = id
+    it.manga_id = mangaId
+    it.media_id = remoteId
+    it.library_id = libraryId
+    it.title = title
+    it.last_chapter_read = lastChapterRead.toFloat()
+    it.total_chapters = totalChapters.toInt()
+    it.status = status.toInt()
+    it.score = score
+    it.tracking_url = remoteUrl
+    it.started_reading_date = startDate
+    it.finished_reading_date = finishDate
+}
+
+fun DbTrack.toDomainTrack(idRequired: Boolean = true): Track? {
+    val trackId = id ?: if (idRequired.not()) -1 else return null
+    return Track(
+        id = trackId,
+        mangaId = manga_id,
+        syncId = sync_id.toLong(),
+        remoteId = media_id,
+        libraryId = library_id,
+        title = title,
+        lastChapterRead = last_chapter_read.toDouble(),
+        totalChapters = total_chapters.toLong(),
+        status = status.toLong(),
+        score = score,
+        remoteUrl = tracking_url,
+        startDate = started_reading_date,
+        finishDate = finished_reading_date,
+    )
+}

app/src/main/java/eu/kanade/domain/track/repository/TrackRepository.kt

@@ -1,10 +1,17 @@
 package eu.kanade.domain.track.repository
 
 import eu.kanade.domain.track.model.Track
+import kotlinx.coroutines.flow.Flow
 
 interface TrackRepository {
 
     suspend fun getTracksByMangaId(mangaId: Long): List<Track>
 
+    suspend fun subscribeTracksByMangaId(mangaId: Long): Flow<List<Track>>
+
+    suspend fun delete(mangaId: Long, syncId: Long)
+
+    suspend fun insert(track: Track)
+
     suspend fun insertAll(tracks: List<Track>)
 }