Revert "Experimental Backup Restore fix"

This reverts commit 3d507600cb3ee456db128b6a0ad189c0f4387b07.

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 }

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) {

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) {
+    suspend fun restoreMangaFetch(source: Source?, manga: Manga, online: Boolean): Manga {
-        manga.apply {
+        return if (online && source != null /* SY --> */ && source !is MergedSource /* SY <-- */) {
-            copyFrom(networkManga.toSManga())
+            val networkManga = source.getMangaDetails(manga.toMangaInfo())
-            favorite = manga.favorite
+            manga.also {
-            initialized = true
+                it.copyFrom(networkManga.toSManga())
-            id = insertManga(manga)
+                it.favorite = manga.favorite
-        }
+                it.initialized = true
-    }
+                it.id = insertManga(manga)
-
+            }
-    fun restoreMangaNoFetch(manga: Manga) {
+        } else {
-        manga.apply {
+            manga.also {
-            initialized = description != null
+                it.initialized = it.description != null
-            id = insertManga(this)
+                it.id = insertManga(it)
+            }
         }
     }
 
@@ -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
-            // If the backupMergedMangaReference is already in the db, assign the id to the file's backupMergedMangaReference
+            var found = false
-            // and do nothing
+            for (dbMergedMangaReference in dbMergedMangaReferences) {
-            val found = dbMergedMangaReferences.any { backupMergedMangaReference.mergeUrl == it.mergeUrl && backupMergedMangaReference.mangaUrl == it.mangaUrl }
+                // If the backupMergedMangaReference is already in the db, assign the id to the file's backupMergedMangaReference
-
+                // and do nothing
+                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) {

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,14 +137,16 @@ class FullBackupRestore(context: Context, notifier: BackupNotifier, private val
     ) {
         val dbManga = backupManager.getMangaFromDatabase(manga)
 
-        if (dbManga == null) {
+        db.inTransaction {
-            // Manga not in database
+            if (dbManga == null) {
-            restoreMangaFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
+                // Manga not in database
-        } else { // Manga in database
+                restoreMangaFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
-            // Copy information from manga already in database
+            } else { // Manga in database
-            backupManager.restoreMangaNoFetch(manga, dbManga)
+                // Copy information from manga already in database
-            // Fetch rest of manga information
+                backupManager.restoreMangaNoFetch(manga, dbManga)
-            restoreMangaNoFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
+                // Fetch rest of manga information
+                restoreMangaNoFetch(source, manga, chapters, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata, online)
+            }
         }
     }
 
@@ -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 <-- */) {
+            val fetchedManga = backupManager.restoreMangaFetch(source, manga, online)
-                source.getMangaDetails(manga.toMangaInfo())
+            fetchedManga.id ?: return
-            } else null
-            val fetchedChapters = if (online && source != null && source !is MergedSource) {
-                backupManager.getChapters(source, manga, throttleManager)
-            } else null
 
-            db.inTransaction {
+            if (online && source != null) {
-                if (networkManga != null) {
+                // SY -->
-                    backupManager.restoreMangaFetch(manga, networkManga)
+                if (source !is MergedSource) {
-                } else {
+                    updateChapters(source, fetchedManga, chapters)
-                    backupManager.restoreMangaNoFetch(manga)
                 }
-
+                // SY <--
-                manga.id ?: return
+            } else {
-
+                backupManager.restoreChaptersForMangaOffline(fetchedManga, chapters)
-                if (fetchedChapters != null && source != null) {
-                    // SY -->
-                    if (source !is MergedSource) {
-                        updateChapters(source, manga, chapters, fetchedChapters)
-                    }
-                    // SY <--
-                } else {
-                    backupManager.restoreChaptersForMangaOffline(manga, chapters)
-                }
-
-                restoreExtraForManga(manga, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata)
             }
 
-            updateTracking(manga, tracks)
+            restoreExtraForManga(fetchedManga, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata)
+
+            updateTracking(fetchedManga, tracks)
         } catch (e: Exception) {
             errors.add(Date() to "${manga.title} - ${e.message}")
         }
@@ -216,24 +203,16 @@ 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()
+        if (online && source != null) {
-
+            if (/* SY --> */ source !is MergedSource && /* SY <-- */ !backupManager.restoreChaptersForManga(backupManga, chapters)) {
-        val fetchedChapters = if (online && source != null && source !is MergedSource && !(dbChapters.isNotEmpty() && dbChapters.size >= chapters.size)) {
+                updateChapters(source, backupManga, chapters)
-            backupManager.getChapters(source, backupManga, throttleManager)
-        } else null
-
-        db.inTransaction {
-            if (fetchedChapters != null && source != null) {
-                if (/* SY --> */ source !is MergedSource && /* SY <-- */ !backupManager.restoreChaptersForManga(backupManga, chapters)) {
-                    updateChapters(source, backupManga, chapters, fetchedChapters)
-                }
-            } else {
-                backupManager.restoreChaptersForMangaOffline(backupManga, chapters)
             }
-
+        } else {
-            restoreExtraForManga(backupManga, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata)
+            backupManager.restoreChaptersForMangaOffline(backupManga, chapters)
         }
 
+        restoreExtraForManga(backupManga, categories, history, tracks, backupCategories, mergedMangaReferences, flatMetadata)
+
         updateTracking(backupManga, tracks)
     }
 

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) {
+    suspend fun fetchManga(source: Source, manga: Manga): Manga {
-        manga.apply {
+        val networkManga = source.getMangaDetails(manga.toMangaInfo())
-            copyFrom(networkManga.toSManga())
+        return manga.also {
-            favorite = true
+            it.copyFrom(networkManga.toSManga())
-            initialized = true
+            it.favorite = true
-            id = insertManga(this)
+            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)
         }
     }
 

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,14 +154,16 @@ class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : Abstract
     ) {
         val dbManga = backupManager.getMangaFromDatabase(manga)
 
-        if (dbManga == null) {
+        db.inTransaction {
-            // Manga not in database
+            if (dbManga == null) {
-            restoreMangaFetch(source, manga, chapters, categories, history, tracks)
+                // Manga not in database
-        } else { // Manga in database
+                restoreMangaFetch(source, manga, chapters, categories, history, tracks)
-            // Copy information from manga already in database
+            } else { // Manga in database
-            backupManager.restoreMangaNoFetch(manga, dbManga)
+                // Copy information from manga already in database
-            // Fetch rest of manga information
+                backupManager.restoreMangaNoFetch(manga, dbManga)
-            restoreMangaNoFetch(source, manga, chapters, categories, history, tracks)
+                // Fetch rest of manga information
+                restoreMangaNoFetch(source, manga, chapters, categories, history, tracks)
+            }
         }
     }
 
@@ -183,19 +183,14 @@ class LegacyBackupRestore(context: Context, notifier: BackupNotifier) : Abstract
         tracks: List<Track>
     ) {
         try {
-            val networkManga = source.getMangaDetails(manga.toMangaInfo())
+            val fetchedManga = backupManager.fetchManga(source, manga)
-            val fetchedChapters = if (source !is MergedSource) {
+            fetchedManga.id ?: return
-                backupManager.getChapters(source, manga, throttleManager)
-            } else emptyList()
-            db.inTransaction {
-                backupManager.fetchManga(networkManga, manga)
-                manga.id ?: return
 
-                updateChapters(source, manga, chapters, fetchedChapters)
+            updateChapters(source, fetchedManga, chapters)
 
-                restoreExtraForManga(manga, categories, history, tracks)
+            restoreExtraForManga(fetchedManga, categories, history, tracks)
-            }
+
-            updateTracking(manga, 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()
+        if (!backupManager.restoreChaptersForManga(backupManga, chapters)) {
-
+            updateChapters(source, backupManga, chapters)
-        val fetchedChapters = if (dbChapters.isNotEmpty() && dbChapters.size >= chapters.size) {
-            backupManager.getChapters(source, backupManga, throttleManager)
-        } else {
-            null
         }
 
-        db.inTransaction {
+        restoreExtraForManga(backupManga, categories, history, tracks)
-            if (!backupManager.restoreChaptersForManga(backupManga, chapters) && fetchedChapters != null) {
-                updateChapters(source, backupManga, chapters, fetchedChapters)
-            }
-
-            restoreExtraForManga(backupManga, categories, history, tracks)
-        }
 
         updateTracking(backupManga, tracks)
     }