Remove drag and drop

2022-07-16 19:49:46 -04:00 · 2022-07-16 19:49:46 -04:00 · dd68ef4ba8
commit dd68ef4ba8
parent b4adab5eb4
15 changed files with 72 additions and 97 deletions
--- a/app/src/main/java/eu/kanade/data/category/CategoryMapper.kt
+++ b/app/src/main/java/eu/kanade/data/category/CategoryMapper.kt
@ -2,14 +2,11 @@ package eu.kanade.data.category

 import eu.kanade.domain.category.model.Category

-val categoryMapper: (Long, String, Long, Long, List<Long>) -> Category = { id, name, order, flags, mangaOrder ->
+val categoryMapper: (Long, String, Long, Long) -> Category = { id, name, order, flags ->
    Category(
        id = id,
        name = name,
        order = order,
        flags = flags,
-        // SY -->
-        mangaOrder = mangaOrder,
-        // SY <--
    )
 }
--- a/app/src/main/java/eu/kanade/data/category/CategoryRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/category/CategoryRepositoryImpl.kt
@ -1,7 +1,6 @@
 package eu.kanade.data.category

 import eu.kanade.data.DatabaseHandler
-import eu.kanade.data.listOfLongsAdapter
 import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.repository.CategoryRepository
@ -39,9 +38,6 @@ class CategoryRepositoryImpl(
                name = category.name,
                order = category.order,
                flags = category.flags,
-                // SY -->
-                mangaOrder = category.mangaOrder,
-                // SY <--
            )
            categoriesQueries.selectLastInsertedRowId()
        }
@ -68,9 +64,6 @@ class CategoryRepositoryImpl(
            order = update.order,
            flags = update.flags,
            categoryId = update.id,
-            // SY -->
-            mangaOrder = update.mangaOrder?.let(listOfLongsAdapter::encode),
-            // SY <--
        )
    }

--- a/app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt
@ -24,7 +24,6 @@ class CreateCategoryWithName(
            name = name,
            order = nextOrder,
            flags = 0,
-            mangaOrder = emptyList(),
        )

        try {
--- a/app/src/main/java/eu/kanade/domain/category/model/Category.kt
+++ b/app/src/main/java/eu/kanade/domain/category/model/Category.kt
@ -14,9 +14,6 @@ data class Category(
    val name: String,
    val order: Long,
    val flags: Long,
-    // SY -->
-    val mangaOrder: List<Long>,
-    // SY <--
 ) : Serializable {

    val displayMode: Long
@ -35,7 +32,6 @@ data class Category(
                name = context.getString(R.string.label_default),
                order = 0,
                flags = 0,
-                mangaOrder = emptyList(),
            )
        }
    }
--- a/app/src/main/java/eu/kanade/domain/category/model/CategoryUpdate.kt
+++ b/app/src/main/java/eu/kanade/domain/category/model/CategoryUpdate.kt
@ -5,7 +5,4 @@ data class CategoryUpdate(
    val name: String? = null,
    val order: Long? = null,
    val flags: Long? = null,
-    // SY -->
-    val mangaOrder: List<Long>? = null,
-    // SY <--
 )
--- 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
@ -293,7 +293,7 @@ class FullBackupManager(context: Context) : AbstractBackupManager(context) {
                    // Let the db assign the id
                    category.id = null
                    category.id = handler.awaitOne {
-                        categoriesQueries.insert(category.name, category.order.toLong(), category.flags.toLong(), category.mangaOrder)
+                        categoriesQueries.insert(category.name, category.order.toLong(), category.flags.toLong())
                        categoriesQueries.selectLastInsertedRowId()
                    }.toInt()
                }
--- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/models/BackupCategory.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/full/models/BackupCategory.kt
@ -12,23 +12,22 @@ class BackupCategory(
    // Bump by 100 to specify this is a 0.x value
    @ProtoNumber(100) var flags: Long = 0,
    // SY specific values
-    @ProtoNumber(600) var mangaOrder: List<Long> = emptyList(),
+    /*@ProtoNumber(600) var mangaOrder: List<Long> = emptyList(),*/
 ) {
    fun getCategoryImpl(): CategoryImpl {
        return CategoryImpl().apply {
            name = this@BackupCategory.name
            flags = this@BackupCategory.flags.toInt()
            order = this@BackupCategory.order.toInt()
-            mangaOrder = this@BackupCategory.mangaOrder
+            /*mangaOrder = this@BackupCategory.mangaOrder*/
        }
    }
 }

-val backupCategoryMapper = { _: Long, name: String, order: Long, flags: Long, mangaOrder: List<Long> ->
+val backupCategoryMapper = { _: Long, name: String, order: Long, flags: Long ->
    BackupCategory(
        name = name,
        order = order,
        flags = flags,
-        mangaOrder = mangaOrder,
    )
 }
--- a/app/src/main/java/eu/kanade/tachiyomi/data/database/models/Category.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/models/Category.kt
@ -16,10 +16,6 @@ interface Category : Serializable {

    var flags: Int

-    // SY -->
-    var mangaOrder: List<Long>
-    // SY <--
-
    private fun setFlags(flag: Int, mask: Int) {
        flags = flags and mask.inv() or (flag and mask)
    }
@ -44,6 +40,5 @@ fun Category.toDomainCategory(): DomainCategory? {
        name = this.name,
        order = this.order.toLong(),
        flags = this.flags.toLong(),
-        mangaOrder = mangaOrder,
    )
 }
--- a/app/src/main/java/eu/kanade/tachiyomi/data/database/models/CategoryImpl.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/database/models/CategoryImpl.kt
@ -10,10 +10,6 @@ class CategoryImpl : Category {

    override var flags: Int = 0

-    // SY -->
-    override var mangaOrder: List<Long> = emptyList()
-    // SY <--
-
    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other == null || javaClass != other.javaClass) return false
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryPresenter.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryPresenter.kt
@ -527,9 +527,6 @@ class LibraryPresenter(
                    i1.manga.date_added.compareTo(i2.manga.date_added)
                }
                // SY -->
-                SortModeSetting.DRAG_AND_DROP -> {
-                    0
-                }
                SortModeSetting.TAG_LIST -> {
                    val manga1IndexOfTag = listOfTags.indexOfFirst { i1.manga.getGenres()?.contains(it) ?: false }
                    val manga2IndexOfTag = listOfTags.indexOfFirst { i2.manga.getGenres()?.contains(it) ?: false }
@ -589,7 +586,7 @@ class LibraryPresenter(
        val items = if (groupType == LibraryGroup.BY_DEFAULT) {
            map
        } else if (!libraryIsGrouped) {
-            editedCategories = listOf(Category(0, "All", 0, 0, emptyList()))
+            editedCategories = listOf(Category(0, "All", 0, 0))
            mapOf(
                0L to map.values.flatten().distinctBy { it.manga.id },
            )
@ -1138,7 +1135,7 @@ class LibraryPresenter(
            LibraryGroup.BY_TRACK_STATUS, LibraryGroup.BY_STATUS -> grouping.values.filter { it.first in map.keys }
            else -> grouping.values
        }.map { (id, name) ->
-            Category(id, name, 0, 0, emptyList())
+            Category(id, name, 0, 0)
        }

        return map to categories
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibrarySettingsSheet.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/library/LibrarySettingsSheet.kt
@ -216,14 +216,13 @@ class LibrarySettingsSheet(
            private val dateAdded = Item.MultiSort(R.string.action_sort_date_added, this)

            // SY -->
-            private val dragAndDrop = Item.MultiSort(R.string.action_sort_drag_and_drop, this)
            private val tagList = Item.MultiSort(R.string.tag_sorting, this)
            // SY <--

            override val header = null

            override val items =
-                listOf(alphabetically, lastRead, lastChecked, unread, total, latestChapter, chapterFetchDate, dateAdded /* SY --> */, dragAndDrop) + if (preferences.sortTagsForLibrary().get().isNotEmpty()) listOf(tagList) else emptyList() // SY <--
+                listOf(alphabetically, lastRead, lastChecked, unread, total, latestChapter, chapterFetchDate, dateAdded /* SY --> */) + if (preferences.sortTagsForLibrary().get().isNotEmpty()) listOf(tagList) else emptyList() // SY <--
            override val footer = null

            override fun initModels() {
@ -251,8 +250,6 @@ class LibrarySettingsSheet(
                dateAdded.state =
                    if (sorting == SortModeSetting.DATE_ADDED) order else Item.MultiSort.SORT_NONE
                // SY -->
-                dragAndDrop.state =
-                    if (sorting == SortModeSetting.DRAG_AND_DROP) order else Item.MultiSort.SORT_NONE
                tagList.state =
                    if (sorting == SortModeSetting.TAG_LIST) order else Item.MultiSort.SORT_NONE
                // SY <--
@ -260,27 +257,19 @@ class LibrarySettingsSheet(

            override fun onItemClicked(item: Item) {
                item as Item.MultiStateGroup
-                // SY -->
-                if (item == dragAndDrop && preferences.groupLibraryBy().get() != LibraryGroup.BY_DEFAULT) return
-                // SY <--
                val prevState = item.state

                item.group.items.forEach {
                    (it as Item.MultiStateGroup).state =
                        Item.MultiSort.SORT_NONE
                }
-                // SY -->
-                if (item == dragAndDrop) {
-                    item.state = Item.MultiSort.SORT_ASC
-                } else {
-                    item.state = when (prevState) {
-                        Item.MultiSort.SORT_NONE -> Item.MultiSort.SORT_ASC
-                        Item.MultiSort.SORT_ASC -> Item.MultiSort.SORT_DESC
-                        Item.MultiSort.SORT_DESC -> Item.MultiSort.SORT_ASC
-                        else -> throw Exception("Unknown state")
-                    }
+
+                item.state = when (prevState) {
+                    Item.MultiSort.SORT_NONE -> Item.MultiSort.SORT_ASC
+                    Item.MultiSort.SORT_ASC -> Item.MultiSort.SORT_DESC
+                    Item.MultiSort.SORT_DESC -> Item.MultiSort.SORT_ASC
+                    else -> throw Exception("Unknown state")
                }
-                // SY <--

                item.state = when (prevState) {
                    Item.MultiSort.SORT_NONE -> Item.MultiSort.SORT_ASC
@ -329,7 +318,6 @@ class LibrarySettingsSheet(
                    chapterFetchDate -> SortModeSetting.CHAPTER_FETCH_DATE
                    dateAdded -> SortModeSetting.DATE_ADDED
                    // SY -->
-                    dragAndDrop -> SortModeSetting.DRAG_AND_DROP
                    tagList -> SortModeSetting.TAG_LIST
                    // SY <--
                    else -> throw NotImplementedError("Unknown display mode")
@ -590,12 +578,6 @@ class LibrarySettingsSheet(

            override fun onItemClicked(item: Item) {
                item as Item.DrawableSelection
-                if (item.id != LibraryGroup.BY_DEFAULT && preferences.librarySortingMode().get() == SortModeSetting.DRAG_AND_DROP) {
-                    preferences.librarySortingMode().set(SortModeSetting.ALPHABETICAL)
-                    preferences.librarySortingAscending().set(SortDirectionSetting.ASCENDING)
-                    sort.adjustDisplaySelection()
-                }
-
                item.group.items.forEach {
                    (it as Item.DrawableSelection).state =
                        Item.DrawableSelection.NOT_SELECTED
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/library/setting/SortModeSetting.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/library/setting/SortModeSetting.kt
@ -12,8 +12,12 @@ enum class SortModeSetting(val flag: Long) {
    LATEST_CHAPTER(0b00010100),
    CHAPTER_FETCH_DATE(0b00011000),
    DATE_ADDED(0b00011100),
+
+    // SY -->
+    @Deprecated("Was unused")
    DRAG_AND_DROP(0b00100000),
    TAG_LIST(0b00100100),
+    // SY <--

    @Deprecated("Use LAST_MANGA_UPDATE")
    LAST_CHECKED(0b00001000),
--- a/app/src/main/java/exh/EXHMigrations.kt
+++ b/app/src/main/java/exh/EXHMigrations.kt
@ -5,6 +5,7 @@ package exh
 import androidx.core.content.edit
 import androidx.preference.PreferenceManager
 import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.category.categoryMapper
 import eu.kanade.data.chapter.chapterMapper
 import eu.kanade.domain.chapter.interactor.DeleteChapters
 import eu.kanade.domain.chapter.interactor.UpdateChapter
@ -39,6 +40,7 @@ import eu.kanade.tachiyomi.ui.library.setting.SortModeSetting
 import eu.kanade.tachiyomi.ui.reader.setting.OrientationType
 import eu.kanade.tachiyomi.util.preference.minusAssign
 import eu.kanade.tachiyomi.util.system.DeviceUtil
+import eu.kanade.tachiyomi.util.system.logcat
 import exh.eh.EHentaiUpdateWorker
 import exh.log.xLogE
 import exh.merged.sql.models.MergedMangaReference
@ -268,36 +270,40 @@ object EXHMigrations {
                    }
                }
                if (oldVersion under 20) {
-                    val oldSortingMode = prefs.getInt(PreferenceKeys.librarySortingMode, 0)
-                    val oldSortingDirection = prefs.getBoolean(PreferenceKeys.librarySortingDirection, true)
+                    try {
+                        val oldSortingMode = prefs.getInt(PreferenceKeys.librarySortingMode, 0)
+                        val oldSortingDirection = prefs.getBoolean(PreferenceKeys.librarySortingDirection, true)

-                    val newSortingMode = when (oldSortingMode) {
-                        LibrarySort.ALPHA -> SortModeSetting.ALPHABETICAL
-                        LibrarySort.LAST_READ -> SortModeSetting.LAST_READ
-                        LibrarySort.LAST_CHECKED -> SortModeSetting.LAST_MANGA_UPDATE
-                        LibrarySort.UNREAD -> SortModeSetting.UNREAD_COUNT
-                        LibrarySort.TOTAL -> SortModeSetting.TOTAL_CHAPTERS
-                        LibrarySort.LATEST_CHAPTER -> SortModeSetting.LATEST_CHAPTER
-                        LibrarySort.CHAPTER_FETCH_DATE -> SortModeSetting.CHAPTER_FETCH_DATE
-                        LibrarySort.DATE_ADDED -> SortModeSetting.DATE_ADDED
-                        LibrarySort.DRAG_AND_DROP -> SortModeSetting.DRAG_AND_DROP
-                        LibrarySort.TAG_LIST -> SortModeSetting.TAG_LIST
-                        else -> SortModeSetting.ALPHABETICAL
-                    }
+                        val newSortingMode = when (oldSortingMode) {
+                            LibrarySort.ALPHA -> SortModeSetting.ALPHABETICAL
+                            LibrarySort.LAST_READ -> SortModeSetting.LAST_READ
+                            LibrarySort.LAST_CHECKED -> SortModeSetting.LAST_MANGA_UPDATE
+                            LibrarySort.UNREAD -> SortModeSetting.UNREAD_COUNT
+                            LibrarySort.TOTAL -> SortModeSetting.TOTAL_CHAPTERS
+                            LibrarySort.LATEST_CHAPTER -> SortModeSetting.LATEST_CHAPTER
+                            LibrarySort.CHAPTER_FETCH_DATE -> SortModeSetting.CHAPTER_FETCH_DATE
+                            LibrarySort.DATE_ADDED -> SortModeSetting.DATE_ADDED
+                            LibrarySort.DRAG_AND_DROP -> SortModeSetting.DRAG_AND_DROP
+                            LibrarySort.TAG_LIST -> SortModeSetting.TAG_LIST
+                            else -> SortModeSetting.ALPHABETICAL
+                        }

-                    val newSortingDirection = when (oldSortingDirection) {
-                        true -> SortDirectionSetting.ASCENDING
-                        else -> SortDirectionSetting.DESCENDING
-                    }
+                        val newSortingDirection = when (oldSortingDirection) {
+                            true -> SortDirectionSetting.ASCENDING
+                            else -> SortDirectionSetting.DESCENDING
+                        }

-                    prefs.edit(commit = true) {
-                        remove(PreferenceKeys.librarySortingMode)
-                        remove(PreferenceKeys.librarySortingDirection)
-                    }
+                        prefs.edit(commit = true) {
+                            remove(PreferenceKeys.librarySortingMode)
+                            remove(PreferenceKeys.librarySortingDirection)
+                        }

-                    prefs.edit {
-                        putString(PreferenceKeys.librarySortingMode, newSortingMode.name)
-                        putString(PreferenceKeys.librarySortingDirection, newSortingDirection.name)
+                        prefs.edit {
+                            putString(PreferenceKeys.librarySortingMode, newSortingMode.name)
+                            putString(PreferenceKeys.librarySortingDirection, newSortingDirection.name)
+                        }
+                    } catch (e: Exception) {
+                        logcat(throwable = e) { "Already done migration" }
                    }
                }
                if (oldVersion under 21) {
@ -413,9 +419,24 @@ object EXHMigrations {
                        SortModeSetting.LAST_CHECKED -> SortModeSetting.LAST_MANGA_UPDATE
                        SortModeSetting.UNREAD -> SortModeSetting.UNREAD_COUNT
                        SortModeSetting.DATE_FETCHED -> SortModeSetting.CHAPTER_FETCH_DATE
+                        SortModeSetting.DRAG_AND_DROP -> SortModeSetting.ALPHABETICAL
                        else -> oldSortingMode
                    }
                    preferences.librarySortingMode().set(newSortingMode)
+                    runBlocking {
+                        handler.await(true) {
+                            categoriesQueries.getCategories(categoryMapper).executeAsList()
+                                .filter { SortModeSetting.fromFlag(it.flags) == SortModeSetting.DRAG_AND_DROP }
+                                .forEach {
+                                    categoriesQueries.update(
+                                        categoryId = it.id,
+                                        flags = it.flags xor SortModeSetting.DRAG_AND_DROP.flag,
+                                        name = null,
+                                        order = null,
+                                    )
+                                }
+                        }
+                    }
                }

                // if (oldVersion under 1) { } (1 is current release version)
--- a/app/src/main/sqldelight/data/categories.sq
+++ b/app/src/main/sqldelight/data/categories.sq
@ -13,8 +13,7 @@ SELECT
 _id AS id,
 name,
 sort AS `order`,
-flags,
-manga_order AS `mangaOrder`
+flags
 FROM categories
 ORDER BY sort;

@ -23,8 +22,7 @@ SELECT
 C._id AS id,
 C.name,
 C.sort AS `order`,
-C.flags,
-C.manga_order AS `mangaOrder`
+C.flags
 FROM categories C
 JOIN mangas_categories MC
 ON C._id = MC.category_id
@ -32,7 +30,7 @@ WHERE MC.manga_id = :mangaId;

 insert:
 INSERT INTO categories(name, sort, flags, manga_order)
-VALUES (:name, :order, :flags, :mangaOrder);
+VALUES (:name, :order, :flags, NULL);

 delete:
 DELETE FROM categories
@ -42,8 +40,7 @@ update:
 UPDATE categories
 SET name = coalesce(:name, name),
    sort = coalesce(:order, sort),
-    flags = coalesce(:flags, flags),
-    manga_order = coalesce(:mangaOrder, manga_order)
+    flags = coalesce(:flags, flags)
 WHERE _id = :categoryId;

 selectLastInsertedRowId:
--- a/app/src/main/sqldelight/migrations/18.sqm
+++ b/app/src/main/sqldelight/migrations/18.sqm
@ -12,4 +12,6 @@ SET cover_last_modified = 0
 WHERE cover_last_modified = -1;
 UPDATE mangas
 SET last_update = 0
-WHERE last_update = -1;
+WHERE last_update = -1;
+UPDATE categories
+SET manga_order = NULL;