Revert "Experimental Backup Restore fix"

This reverts commit 3d507600cb3ee456db128b6a0ad189c0f4387b07.
2021-03-11 19:44:36 -05:00 · 2021-03-11 19:44:36 -05:00 · e9fd6ab470
commit e9fd6ab470
parent 3d507600cb
6 changed files with 96 additions and 129 deletions
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/AbstractBackupManager.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/AbstractBackupManager.kt
@ -10,7 +10,6 @@ import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.data.track.TrackManager
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.SourceManager
-import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.model.toSChapter
 import eu.kanade.tachiyomi.source.online.all.EHentai
 import eu.kanade.tachiyomi.util.chapter.syncChaptersWithSource
@ -34,16 +33,6 @@ abstract class AbstractBackupManager(protected val context: Context) {
    internal fun getMangaFromDatabase(manga: Manga): Manga? =
        databaseHelper.getManga(manga.url, manga.source).executeAsBlocking()

-    internal suspend fun getChapters(source: Source, manga: Manga /* SY --> */, throttleManager: EHentaiThrottleManager /* SY <-- */): List<SChapter> {
-        return if (source is EHentai) {
-            source.getChapterList(manga.toMangaInfo(), throttleManager::throttle)
-                .map { it.toSChapter() }
-        } else {
-            source.getChapterList(manga.toMangaInfo())
-                .map { it.toSChapter() }
-        }
-    }
-
    /**
     * Fetches chapter information.
     *
@ -52,7 +41,16 @@ abstract class AbstractBackupManager(protected val context: Context) {
     * @param chapters list of chapters in the backup
     * @return Updated manga chapters.
     */
-    internal open suspend fun restoreChapters(source: Source, manga: Manga, chapters: List<Chapter>, fetchedChapters: List<SChapter>): Pair<List<Chapter>, List<Chapter>> {
+    internal open suspend fun restoreChapters(source: Source, manga: Manga, chapters: List<Chapter> /* SY --> */, throttleManager: EHentaiThrottleManager /* SY <-- */): Pair<List<Chapter>, List<Chapter>> {
+        // SY -->
+        val fetchedChapters = if (source is EHentai) {
+            source.getChapterList(manga.toMangaInfo(), throttleManager::throttle)
+                .map { it.toSChapter() }
+        } else {
+            source.getChapterList(manga.toMangaInfo())
+                .map { it.toSChapter() }
+        }
+        // SY <--
        val syncedChapters = syncChaptersWithSource(databaseHelper, fetchedChapters, manga, source)
        if (syncedChapters.first.isNotEmpty()) {
            chapters.forEach { it.manga_id = manga.id }
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/AbstractBackupRestore.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/AbstractBackupRestore.kt
@ -9,7 +9,6 @@ import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.data.database.models.Track
 import eu.kanade.tachiyomi.data.track.TrackManager
 import eu.kanade.tachiyomi.source.Source
-import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.util.chapter.NoChaptersException
 import eu.kanade.tachiyomi.util.system.createFileInCacheDir
 import exh.eh.EHentaiThrottleManager
@ -70,9 +69,9 @@ abstract class AbstractBackupRestore<T : AbstractBackupManager>(protected val co
     * @param manga manga that needs updating
     * @return Updated manga chapters.
     */
-    internal suspend fun updateChapters(source: Source, manga: Manga, chapters: List<Chapter>, fetchedChapters: List<SChapter>): Pair<List<Chapter>, List<Chapter>> {
+    internal suspend fun updateChapters(source: Source, manga: Manga, chapters: List<Chapter>): Pair<List<Chapter>, List<Chapter>> {
        return try {
-            backupManager.restoreChapters(source, manga, chapters, fetchedChapters)
+            backupManager.restoreChapters(source, manga, chapters /* SY --> */, throttleManager /* SY <-- */)
        } catch (e: Exception) {
            // If there's any error, return empty update and continue.
            val errorMessage = if (e is NoChaptersException) {
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupManager.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupManager.kt
@ -29,9 +29,11 @@ import eu.kanade.tachiyomi.data.database.models.History
 import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.data.database.models.MangaCategory
 import eu.kanade.tachiyomi.data.database.models.Track
+import eu.kanade.tachiyomi.data.database.models.toMangaInfo
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.model.toSManga
 import eu.kanade.tachiyomi.source.online.MetadataSource
+import eu.kanade.tachiyomi.source.online.all.MergedSource
 import exh.metadata.metadata.base.getFlatMetadataForManga
 import exh.metadata.metadata.base.insertFlatMetadataAsync
 import exh.savedsearches.JsonSavedSearch
@ -45,7 +47,6 @@ import kotlinx.serialization.protobuf.ProtoBuf
 import okio.buffer
 import okio.gzip
 import okio.sink
-import tachiyomi.source.model.MangaInfo
 import timber.log.Timber
 import kotlin.math.max

@ -240,19 +241,20 @@ class FullBackupManager(context: Context) : AbstractBackupManager(context) {
     * @param manga manga that needs updating
     * @return Updated manga info.
     */
-    fun restoreMangaFetch(manga: Manga, networkManga: MangaInfo) {
-        manga.apply {
-            copyFrom(networkManga.toSManga())
-            favorite = manga.favorite
-            initialized = true
-            id = insertManga(manga)
+    suspend fun restoreMangaFetch(source: Source?, manga: Manga, online: Boolean): Manga {
+        return if (online && source != null /* SY --> */ && source !is MergedSource /* SY <-- */) {
+            val networkManga = source.getMangaDetails(manga.toMangaInfo())
+            manga.also {
+                it.copyFrom(networkManga.toSManga())
+                it.favorite = manga.favorite
+                it.initialized = true
+                it.id = insertManga(manga)
            }
+        } else {
+            manga.also {
+                it.initialized = it.description != null
+                it.id = insertManga(it)
            }
-
-    fun restoreMangaNoFetch(manga: Manga) {
-        manga.apply {
-            initialized = description != null
-            id = insertManga(this)
        }
    }

@ -497,18 +499,21 @@ class FullBackupManager(context: Context) : AbstractBackupManager(context) {
     * @param backupMergedMangaReferences the list of backup manga references for the merged manga
     */
    internal fun restoreMergedMangaReferencesForManga(manga: Manga, backupMergedMangaReferences: List<BackupMergedMangaReference>) {
-        if (backupMergedMangaReferences.isEmpty()) return
-
        // Get merged manga references from file and from db
        val dbMergedMangaReferences = databaseHelper.getMergedMangaReferences().executeAsBlocking()

        // Iterate over them
        backupMergedMangaReferences.forEach { backupMergedMangaReference ->
            // Used to know if the merged manga reference is already in the db
+            var found = false
+            for (dbMergedMangaReference in dbMergedMangaReferences) {
                // If the backupMergedMangaReference is already in the db, assign the id to the file's backupMergedMangaReference
                // and do nothing
-            val found = dbMergedMangaReferences.any { backupMergedMangaReference.mergeUrl == it.mergeUrl && backupMergedMangaReference.mangaUrl == it.mangaUrl }
-
+                if (backupMergedMangaReference.mergeUrl == dbMergedMangaReference.mergeUrl && backupMergedMangaReference.mangaUrl == dbMergedMangaReference.mangaUrl) {
+                    found = true
+                    break
+                }
+            }
            // If the backupMergedMangaReference isn't in the db, remove the id and insert a new backupMergedMangaReference
            // Store the inserted id in the backupMergedMangaReference
            if (!found) {
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupRestore.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/FullBackupRestore.kt
@ -15,7 +15,6 @@ import eu.kanade.tachiyomi.data.backup.full.models.BackupSerializer
 import eu.kanade.tachiyomi.data.database.models.Chapter
 import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.data.database.models.Track
-import eu.kanade.tachiyomi.data.database.models.toMangaInfo
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.source.online.all.MergedSource
 import exh.EXHMigrations
@ -138,6 +137,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
    ) {
        val dbManga = backupManager.getMangaFromDatabase(manga)

+        db.inTransaction {
            if (dbManga == null) {
                // Manga not in database
                restoreMangaFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
@ -148,6 +148,7 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
                restoreMangaNoFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
            }
        }
+    }

    /**
     * Fetches manga information
@ -169,36 +170,22 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
        online: Boolean
    ) {
        try {
-            val networkManga = if (online && source != null /* SY --> */ && source !is MergedSource /* SY <-- */) {
-                source.getMangaDetails(manga.toMangaInfo())
-            } else null
-            val fetchedChapters = if (online && source != null && source !is MergedSource) {
-                backupManager.getChapters(source, manga, throttleManager)
-            } else null
+            val fetchedManga = backupManager.restoreMangaFetch(source, manga, online)
+            fetchedManga.id ?: return

-            db.inTransaction {
-                if (networkManga != null) {
-                    backupManager.restoreMangaFetch(manga, networkManga)
-                } else {
-                    backupManager.restoreMangaNoFetch(manga)
-                }
-
-                manga.id ?: return
-
-                if (fetchedChapters != null && source != null) {
+            if (online && source != null) {
                // SY -->
                if (source !is MergedSource) {
-                        updateChapters(source, manga, chapters, fetchedChapters)
+                    updateChapters(source, fetchedManga, chapters)
                }
                // SY <--
            } else {
-                    backupManager.restoreChaptersForMangaOffline(manga, chapters)
+                backupManager.restoreChaptersForMangaOffline(fetchedManga, chapters)
            }

-                restoreExtraForManga(manga, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata)
-            }
+            restoreExtraForManga(fetchedManga, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata)

-            updateTracking(manga, tracks)
+            updateTracking(fetchedManga, tracks)
        } catch (e: Exception) {
            errors.add(Date() to "${manga.title} - ${e.message}")
        }
@ -216,23 +203,15 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
        flatMetadata: BackupFlatMetadata?,
        online: Boolean
    ) {
-        val dbChapters = if (source !is MergedSource) backupManager.databaseHelper.getChapters(backupManga).executeAsBlocking() else emptyList()
-
-        val fetchedChapters = if (online && source != null && source !is MergedSource && !(dbChapters.isNotEmpty() && dbChapters.size >= chapters.size)) {
-            backupManager.getChapters(source, backupManga, throttleManager)
-        } else null
-
-        db.inTransaction {
-            if (fetchedChapters != null && source != null) {
+        if (online && source != null) {
            if (/* SY --> */ source !is MergedSource && /* SY <-- */ !backupManager.restoreChaptersForManga(backupManga, chapters)) {
-                    updateChapters(source, backupManga, chapters, fetchedChapters)
+                updateChapters(source, backupManga, chapters)
            }
        } else {
            backupManager.restoreChaptersForMangaOffline(backupManga, chapters)
        }

        restoreExtraForManga(backupManga, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata)
-        }

        updateTracking(backupManga, tracks)
    }
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupManager.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupManager.kt
@ -48,19 +48,19 @@ import eu.kanade.tachiyomi.data.database.models.MangaCategory
 import eu.kanade.tachiyomi.data.database.models.MangaImpl
 import eu.kanade.tachiyomi.data.database.models.Track
 import eu.kanade.tachiyomi.data.database.models.TrackImpl
+import eu.kanade.tachiyomi.data.database.models.toMangaInfo
 import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.source.LocalSource
 import eu.kanade.tachiyomi.source.Source
-import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.model.toSManga
 import eu.kanade.tachiyomi.source.online.all.MergedSource
+import exh.eh.EHentaiThrottleManager
 import exh.merged.sql.models.MergedMangaReference
 import exh.savedsearches.JsonSavedSearch
 import exh.source.MERGED_SOURCE_ID
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import tachiyomi.source.model.MangaInfo
 import timber.log.Timber
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@ -278,12 +278,13 @@ class LegacyBackupManager(context: Context, version: Int = CURRENT_VERSION) : Ab
     * @param manga manga that needs updating
     * @return Updated manga.
     */
-    fun fetchManga(networkManga: MangaInfo, manga: Manga) {
-        manga.apply {
-            copyFrom(networkManga.toSManga())
-            favorite = true
-            initialized = true
-            id = insertManga(this)
+    suspend fun fetchManga(source: Source, manga: Manga): Manga {
+        val networkManga = source.getMangaDetails(manga.toMangaInfo())
+        return manga.also {
+            it.copyFrom(networkManga.toSManga())
+            it.favorite = true
+            it.initialized = true
+            it.id = insertManga(manga)
        }
    }

@ -294,7 +295,7 @@ class LegacyBackupManager(context: Context, version: Int = CURRENT_VERSION) : Ab
     * @param manga manga that needs updating
     * @return [Observable] that contains manga
     */
-    override suspend fun restoreChapters(source: Source, manga: Manga, chapters: List<Chapter>, fetchedChapters: List<SChapter>): Pair<List<Chapter>, List<Chapter>> {
+    override suspend fun restoreChapters(source: Source, manga: Manga, chapters: List<Chapter>, throttleManager: EHentaiThrottleManager): Pair<List<Chapter>, List<Chapter>> {
        // SY -->
        return if (source is MergedSource) {
            val syncedChapters = source.fetchChaptersAndSync(manga, false)
@ -304,7 +305,7 @@ class LegacyBackupManager(context: Context, version: Int = CURRENT_VERSION) : Ab
            updateChapters(syncedChapters.first)
            syncedChapters
        } else {
-            super.restoreChapters(source, manga, chapters, fetchedChapters)
+            super.restoreChapters(source, manga, chapters, throttleManager)
        }
    }

--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupRestore.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/legacy/LegacyBackupRestore.kt
@ -20,9 +20,7 @@ import eu.kanade.tachiyomi.data.database.models.Manga
 import eu.kanade.tachiyomi.data.database.models.MangaImpl
 import eu.kanade.tachiyomi.data.database.models.Track
 import eu.kanade.tachiyomi.data.database.models.TrackImpl
-import eu.kanade.tachiyomi.data.database.models.toMangaInfo
 import eu.kanade.tachiyomi.source.Source
-import eu.kanade.tachiyomi.source.online.all.MergedSource
 import exh.EXHMigrations
 import java.util.Date

@ -156,6 +154,7 @@ class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : Abstract
    ) {
        val dbManga = backupManager.getMangaFromDatabase(manga)

+        db.inTransaction {
            if (dbManga == null) {
                // Manga not in database
                restoreMangaFetch(source, manga, chapters, categories, history, tracks)
@ -166,6 +165,7 @@ class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : Abstract
                restoreMangaNoFetch(source, manga, chapters, categories, history, tracks)
            }
        }
+    }

    /**
     * Fetches manga information.
@ -183,19 +183,14 @@ class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : Abstract
        tracks: List<Track>
    ) {
        try {
-            val networkManga = source.getMangaDetails(manga.toMangaInfo())
-            val fetchedChapters = if (source !is MergedSource) {
-                backupManager.getChapters(source, manga, throttleManager)
-            } else emptyList()
-            db.inTransaction {
-                backupManager.fetchManga(networkManga, manga)
-                manga.id ?: return
+            val fetchedManga = backupManager.fetchManga(source, manga)
+            fetchedManga.id ?: return

-                updateChapters(source, manga, chapters, fetchedChapters)
+            updateChapters(source, fetchedManga, chapters)

-                restoreExtraForManga(manga, categories, history, tracks)
-            }
-            updateTracking(manga, tracks)
+            restoreExtraForManga(fetchedManga, categories, history, tracks)
+
+            updateTracking(fetchedManga, tracks)
        } catch (e: Exception) {
            errors.add(Date() to "${manga.title} - ${e.message}")
        }
@ -209,21 +204,11 @@ class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : Abstract
        history: List<DHistory>,
        tracks: List<Track>
    ) {
-        val dbChapters = backupManager.databaseHelper.getChapters(backupManga).executeAsBlocking()
-
-        val fetchedChapters = if (dbChapters.isNotEmpty() && dbChapters.size >= chapters.size) {
-            backupManager.getChapters(source, backupManga, throttleManager)
-        } else {
-            null
-        }
-
-        db.inTransaction {
-            if (!backupManager.restoreChaptersForManga(backupManga, chapters) && fetchedChapters != null) {
-                updateChapters(source, backupManga, chapters, fetchedChapters)
+        if (!backupManager.restoreChaptersForManga(backupManga, chapters)) {
+            updateChapters(source, backupManga, chapters)
        }

        restoreExtraForManga(backupManga, categories, history, tracks)
-        }

        updateTracking(backupManga, tracks)
    }