Move more implementation to data module

2023-02-09 16:17:00 -05:00
parent 120ea4c768
commit c0e9471608
14 changed files with 18 additions and 28 deletions
@@ -0,0 +1,14 @@
+package tachiyomi.data.manga
+
+import tachiyomi.domain.manga.model.FavoriteEntry
+
+val favoriteEntryMapper: (Long, String, String, String, Long) -> FavoriteEntry =
+    { id, title, gid, token, category ->
+        FavoriteEntry(
+            id = id,
+            title = title,
+            gid = gid,
+            token = token,
+            category = category.toInt(),
+        )
+    }
@@ -0,0 +1,25 @@
+package tachiyomi.data.manga
+
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.manga.model.FavoriteEntry
+import tachiyomi.domain.manga.repository.FavoritesEntryRepository
+
+class FavoritesEntryRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : FavoritesEntryRepository {
+    override suspend fun deleteAll() {
+        handler.await { eh_favoritesQueries.deleteAll() }
+    }
+
+    override suspend fun insertAll(favoriteEntries: List<FavoriteEntry>) {
+        handler.await(true) {
+            favoriteEntries.forEach {
+                eh_favoritesQueries.insertEhFavorites(it.id, it.title, it.gid, it.token, it.category.toLong())
+            }
+        }
+    }
+
+    override suspend fun selectAll(): List<FavoriteEntry> {
+        return handler.awaitList { eh_favoritesQueries.selectAll(favoriteEntryMapper) }
+    }
+}
@@ -0,0 +1,128 @@
+package tachiyomi.data.manga
+
+import eu.kanade.tachiyomi.util.system.logcat
+import eu.kanade.tachiyomi.util.toLong
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.model.MergeMangaSettingsUpdate
+import tachiyomi.domain.manga.model.MergedMangaReference
+import tachiyomi.domain.manga.repository.MangaMergeRepository
+
+class MangaMergeRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : MangaMergeRepository {
+
+    override suspend fun getMergedManga(): List<Manga> {
+        return handler.awaitList { mergedQueries.selectAllMergedMangas(mangaMapper) }
+    }
+
+    override suspend fun subscribeMergedManga(): Flow<List<Manga>> {
+        return handler.subscribeToList { mergedQueries.selectAllMergedMangas(mangaMapper) }
+    }
+
+    override suspend fun getMergedMangaById(id: Long): List<Manga> {
+        return handler.awaitList { mergedQueries.selectMergedMangasById(id, mangaMapper) }
+    }
+
+    override suspend fun subscribeMergedMangaById(id: Long): Flow<List<Manga>> {
+        return handler.subscribeToList { mergedQueries.selectMergedMangasById(id, mangaMapper) }
+    }
+
+    override suspend fun getReferencesById(id: Long): List<MergedMangaReference> {
+        return handler.awaitList { mergedQueries.selectByMergeId(id, mergedMangaReferenceMapper) }
+    }
+
+    override suspend fun subscribeReferencesById(id: Long): Flow<List<MergedMangaReference>> {
+        return handler.subscribeToList { mergedQueries.selectByMergeId(id, mergedMangaReferenceMapper) }
+    }
+
+    override suspend fun updateSettings(update: MergeMangaSettingsUpdate): Boolean {
+        return try {
+            partialUpdate(update)
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    override suspend fun updateAllSettings(values: List<MergeMangaSettingsUpdate>): Boolean {
+        return try {
+            partialUpdate(*values.toTypedArray())
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    private suspend fun partialUpdate(vararg values: MergeMangaSettingsUpdate) {
+        handler.await(inTransaction = true) {
+            values.forEach { value ->
+                mergedQueries.updateSettingsById(
+                    id = value.id,
+                    getChapterUpdates = value.getChapterUpdates?.toLong(),
+                    downloadChapters = value.downloadChapters?.toLong(),
+                    infoManga = value.isInfoManga?.toLong(),
+                    chapterPriority = value.chapterPriority?.toLong(),
+                    chapterSortMode = value.chapterSortMode?.toLong(),
+                )
+            }
+        }
+    }
+
+    override suspend fun insert(reference: MergedMangaReference): Long? {
+        return handler.awaitOneOrNull {
+            mergedQueries.insert(
+                infoManga = reference.isInfoManga,
+                getChapterUpdates = reference.getChapterUpdates,
+                chapterSortMode = reference.chapterSortMode.toLong(),
+                chapterPriority = reference.chapterPriority.toLong(),
+                downloadChapters = reference.downloadChapters,
+                mergeId = reference.mergeId!!,
+                mergeUrl = reference.mergeUrl,
+                mangaId = reference.mangaId,
+                mangaUrl = reference.mangaUrl,
+                mangaSource = reference.mangaSourceId,
+            )
+            mergedQueries.selectLastInsertedRowId()
+        }
+    }
+
+    override suspend fun insertAll(references: List<MergedMangaReference>) {
+        handler.await(true) {
+            references.forEach { reference ->
+                mergedQueries.insert(
+                    infoManga = reference.isInfoManga,
+                    getChapterUpdates = reference.getChapterUpdates,
+                    chapterSortMode = reference.chapterSortMode.toLong(),
+                    chapterPriority = reference.chapterPriority.toLong(),
+                    downloadChapters = reference.downloadChapters,
+                    mergeId = reference.mergeId!!,
+                    mergeUrl = reference.mergeUrl,
+                    mangaId = reference.mangaId,
+                    mangaUrl = reference.mangaUrl,
+                    mangaSource = reference.mangaSourceId,
+                )
+            }
+        }
+    }
+
+    override suspend fun deleteById(id: Long) {
+        handler.await {
+            mergedQueries.deleteById(id)
+        }
+    }
+
+    override suspend fun deleteByMergeId(mergeId: Long) {
+        handler.await {
+            mergedQueries.deleteByMergeId(mergeId)
+        }
+    }
+
+    override suspend fun getMergeMangaForDownloading(mergeId: Long): List<Manga> {
+        return handler.awaitList { mergedQueries.selectMergedMangasForDownloadingById(mergeId, mangaMapper) }
+    }
+}
@@ -0,0 +1,71 @@
+package tachiyomi.data.manga
+
+import exh.metadata.metadata.base.FlatMetadata
+import exh.metadata.sql.models.SearchMetadata
+import exh.metadata.sql.models.SearchTag
+import exh.metadata.sql.models.SearchTitle
+import exh.source.EH_SOURCE_ID
+import exh.source.EXH_SOURCE_ID
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.manga.model.Manga
+import tachiyomi.domain.manga.repository.MangaMetadataRepository
+
+class MangaMetadataRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : MangaMetadataRepository {
+
+    override suspend fun getMetadataById(id: Long): SearchMetadata? {
+        return handler.awaitOneOrNull { search_metadataQueries.selectByMangaId(id, searchMetadataMapper) }
+    }
+
+    override fun subscribeMetadataById(id: Long): Flow<SearchMetadata?> {
+        return handler.subscribeToOneOrNull { search_metadataQueries.selectByMangaId(id, searchMetadataMapper) }
+    }
+
+    override suspend fun getTagsById(id: Long): List<SearchTag> {
+        return handler.awaitList { search_tagsQueries.selectByMangaId(id, searchTagMapper) }
+    }
+
+    override fun subscribeTagsById(id: Long): Flow<List<SearchTag>> {
+        return handler.subscribeToList { search_tagsQueries.selectByMangaId(id, searchTagMapper) }
+    }
+
+    override suspend fun getTitlesById(id: Long): List<SearchTitle> {
+        return handler.awaitList { search_titlesQueries.selectByMangaId(id, searchTitleMapper) }
+    }
+
+    override fun subscribeTitlesById(id: Long): Flow<List<SearchTitle>> {
+        return handler.subscribeToList { search_titlesQueries.selectByMangaId(id, searchTitleMapper) }
+    }
+
+    override suspend fun insertFlatMetadata(flatMetadata: FlatMetadata) {
+        require(flatMetadata.metadata.mangaId != -1L)
+
+        handler.await(true) {
+            flatMetadata.metadata.run {
+                search_metadataQueries.upsert(mangaId, uploader, extra, indexedExtra, extraVersion)
+            }
+            search_tagsQueries.deleteByManga(flatMetadata.metadata.mangaId)
+            flatMetadata.tags.forEach {
+                search_tagsQueries.insert(it.mangaId, it.namespace, it.name, it.type)
+            }
+            search_titlesQueries.deleteByManga(flatMetadata.metadata.mangaId)
+            flatMetadata.titles.forEach {
+                search_titlesQueries.insert(it.mangaId, it.title, it.type)
+            }
+        }
+    }
+
+    override suspend fun getExhFavoriteMangaWithMetadata(): List<Manga> {
+        return handler.awaitList { mangasQueries.getEhMangaWithMetadata(EH_SOURCE_ID, EXH_SOURCE_ID, mangaMapper) }
+    }
+
+    override suspend fun getIdsOfFavoriteMangaWithMetadata(): List<Long> {
+        return handler.awaitList { mangasQueries.getIdsOfFavoriteMangaWithMetadata() }
+    }
+
+    override suspend fun getSearchMetadata(): List<SearchMetadata> {
+        return handler.awaitList { search_metadataQueries.selectAll(searchMetadataMapper) }
+    }
+}
@@ -0,0 +1,20 @@
+package tachiyomi.data.manga
+
+import tachiyomi.domain.manga.model.MergedMangaReference
+
+val mergedMangaReferenceMapper =
+    { id: Long, isInfoManga: Boolean, getChapterUpdates: Boolean, chapterSortMode: Long, chapterPriority: Long, downloadChapters: Boolean, mergeId: Long, mergeUrl: String, mangaId: Long?, mangaUrl: String, mangaSourceId: Long ->
+        MergedMangaReference(
+            id = id,
+            isInfoManga = isInfoManga,
+            getChapterUpdates = getChapterUpdates,
+            chapterSortMode = chapterSortMode.toInt(),
+            chapterPriority = chapterPriority.toInt(),
+            downloadChapters = downloadChapters,
+            mergeId = mergeId,
+            mergeUrl = mergeUrl,
+            mangaId = mangaId,
+            mangaUrl = mangaUrl,
+            mangaSourceId = mangaSourceId,
+        )
+    }
@@ -0,0 +1,14 @@
+package tachiyomi.data.manga
+
+import exh.metadata.sql.models.SearchMetadata
+
+val searchMetadataMapper: (Long, String?, String, String?, Int) -> SearchMetadata =
+    { mangaId, uploader, extra, indexedExtra, extraVersion ->
+        SearchMetadata(
+            mangaId = mangaId,
+            uploader = uploader,
+            extra = extra,
+            indexedExtra = indexedExtra,
+            extraVersion = extraVersion,
+        )
+    }
@@ -0,0 +1,14 @@
+package tachiyomi.data.manga
+
+import exh.metadata.sql.models.SearchTag
+
+val searchTagMapper: (Long, Long, String?, String, Int) -> SearchTag =
+    { id, mangaId, namespace, name, type ->
+        SearchTag(
+            id = id,
+            mangaId = mangaId,
+            namespace = namespace,
+            name = name,
+            type = type,
+        )
+    }
@@ -0,0 +1,13 @@
+package tachiyomi.data.manga
+
+import exh.metadata.sql.models.SearchTitle
+
+val searchTitleMapper: (Long, Long, String, Int) -> SearchTitle =
+    { id, mangaId, title, type ->
+        SearchTitle(
+            id = id,
+            mangaId = mangaId,
+            title = title,
+            type = type,
+        )
+    }
@@ -0,0 +1,13 @@
+package tachiyomi.data.source
+
+import tachiyomi.domain.source.model.FeedSavedSearch
+
+val feedSavedSearchMapper: (Long, Long, Long?, Boolean) -> FeedSavedSearch =
+    { id, source, savedSearch, global ->
+        FeedSavedSearch(
+            id = id,
+            source = source,
+            savedSearch = savedSearch,
+            global = global,
+        )
+    }
@@ -0,0 +1,71 @@
+package tachiyomi.data.source
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.source.model.FeedSavedSearch
+import tachiyomi.domain.source.model.SavedSearch
+import tachiyomi.domain.source.repository.FeedSavedSearchRepository
+
+class FeedSavedSearchRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : FeedSavedSearchRepository {
+
+    override suspend fun getGlobal(): List<FeedSavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectAllGlobal(feedSavedSearchMapper) }
+    }
+
+    override fun getGlobalAsFlow(): Flow<List<FeedSavedSearch>> {
+        return handler.subscribeToList { feed_saved_searchQueries.selectAllGlobal(feedSavedSearchMapper) }
+    }
+
+    override suspend fun getGlobalFeedSavedSearch(): List<SavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectGlobalFeedSavedSearch(savedSearchMapper) }
+    }
+
+    override suspend fun countGlobal(): Long {
+        return handler.awaitOne { feed_saved_searchQueries.countGlobal() }
+    }
+
+    override suspend fun getBySourceId(sourceId: Long): List<FeedSavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectBySource(sourceId, feedSavedSearchMapper) }
+    }
+
+    override fun getBySourceIdAsFlow(sourceId: Long): Flow<List<FeedSavedSearch>> {
+        return handler.subscribeToList { feed_saved_searchQueries.selectBySource(sourceId, feedSavedSearchMapper) }
+    }
+
+    override suspend fun getBySourceIdFeedSavedSearch(sourceId: Long): List<SavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectSourceFeedSavedSearch(sourceId, savedSearchMapper) }
+    }
+
+    override suspend fun countBySourceId(sourceId: Long): Long {
+        return handler.awaitOne { feed_saved_searchQueries.countSourceFeedSavedSearch(sourceId) }
+    }
+
+    override suspend fun delete(feedSavedSearchId: Long) {
+        handler.await { feed_saved_searchQueries.deleteById(feedSavedSearchId) }
+    }
+
+    override suspend fun insert(feedSavedSearch: FeedSavedSearch): Long {
+        return handler.awaitOne(true) {
+            feed_saved_searchQueries.insert(
+                feedSavedSearch.source,
+                feedSavedSearch.savedSearch,
+                feedSavedSearch.global,
+            )
+            feed_saved_searchQueries.selectLastInsertedRowId()
+        }
+    }
+
+    override suspend fun insertAll(feedSavedSearch: List<FeedSavedSearch>) {
+        return handler.await(true) {
+            feedSavedSearch.forEach {
+                feed_saved_searchQueries.insert(
+                    it.source,
+                    it.savedSearch,
+                    it.global,
+                )
+            }
+        }
+    }
+}
@@ -0,0 +1,14 @@
+package tachiyomi.data.source
+
+import tachiyomi.domain.source.model.SavedSearch
+
+val savedSearchMapper: (Long, Long, String, String?, String?) -> SavedSearch =
+    { id, source, name, query, filtersJson ->
+        SavedSearch(
+            id = id,
+            source = source,
+            name = name,
+            query = query,
+            filtersJson = filtersJson,
+        )
+    }
@@ -0,0 +1,52 @@
+package tachiyomi.data.source
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.source.model.SavedSearch
+import tachiyomi.domain.source.repository.SavedSearchRepository
+
+class SavedSearchRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : SavedSearchRepository {
+
+    override suspend fun getById(savedSearchId: Long): SavedSearch? {
+        return handler.awaitOneOrNull { saved_searchQueries.selectById(savedSearchId, savedSearchMapper) }
+    }
+
+    override suspend fun getBySourceId(sourceId: Long): List<SavedSearch> {
+        return handler.awaitList { saved_searchQueries.selectBySource(sourceId, savedSearchMapper) }
+    }
+
+    override fun getBySourceIdAsFlow(sourceId: Long): Flow<List<SavedSearch>> {
+        return handler.subscribeToList { saved_searchQueries.selectBySource(sourceId, savedSearchMapper) }
+    }
+
+    override suspend fun delete(savedSearchId: Long) {
+        handler.await { saved_searchQueries.deleteById(savedSearchId) }
+    }
+
+    override suspend fun insert(savedSearch: SavedSearch): Long {
+        return handler.awaitOne(true) {
+            saved_searchQueries.insert(
+                savedSearch.source,
+                savedSearch.name,
+                savedSearch.query,
+                savedSearch.filtersJson,
+            )
+            saved_searchQueries.selectLastInsertedRowId()
+        }
+    }
+
+    override suspend fun insertAll(savedSearch: List<SavedSearch>) {
+        handler.await(true) {
+            savedSearch.forEach {
+                saved_searchQueries.insert(
+                    it.source,
+                    it.name,
+                    it.query,
+                    it.filtersJson,
+                )
+            }
+        }
+    }
+}