From 48ef273fb20504e275f15347e0929e4a70d6f588 Mon Sep 17 00:00:00 2001 From: Caleb Morris Date: Sat, 21 Oct 2023 18:42:09 -0700 Subject: [PATCH] Changed data-mappers to use function format (#10045) The lambda-format was really confusing to read and keep which anonymous data item was corresponding to which field. Now it's directly inspectable in the IDE (cherry picked from commit 15423bfc8476179dff20ed49e5aa92a5387061ff) # Conflicts: # data/src/main/java/tachiyomi/data/chapter/ChapterRepositoryImpl.kt # data/src/main/java/tachiyomi/data/manga/MangaMapper.kt # data/src/main/java/tachiyomi/data/manga/MangaRepositoryImpl.kt # data/src/main/java/tachiyomi/data/updates/UpdatesMapper.kt # data/src/main/java/tachiyomi/data/updates/UpdatesRepositoryImpl.kt --- .../tachiyomi/data/backup/BackupCreator.kt | 4 +- .../tachiyomi/data/backup/BackupRestorer.kt | 8 +- app/src/main/java/exh/EXHMigrations.kt | 10 +- .../tachiyomi/data/category/CategoryMapper.kt | 21 +- .../data/category/CategoryRepositoryImpl.kt | 10 +- .../tachiyomi/data/chapter/ChapterMapper.kt | 63 ++--- .../data/chapter/ChapterRepositoryImpl.kt | 16 +- .../tachiyomi/data/history/HistoryMapper.kt | 38 +-- .../data/history/HistoryRepositoryImpl.kt | 8 +- .../tachiyomi/data/manga/FavoriteEntry.kt | 15 - .../manga/FavoritesEntryRepositoryImpl.kt | 20 +- .../java/tachiyomi/data/manga/MangaMapper.kt | 264 +++++++++++------- .../data/manga/MangaMergeRepositoryImpl.kt | 14 +- .../data/manga/MangaMetadataRepositoryImpl.kt | 62 +++- .../data/manga/MangaRepositoryImpl.kt | 26 +- ...eferenceMapper.kt => MergedMangaMapper.kt} | 19 +- .../data/manga/SearchMetadataMapper.kt | 14 - .../java/tachiyomi/data/manga/SearchTag.kt | 14 - .../java/tachiyomi/data/manga/SearchTitle.kt | 13 - ...avedSearch.kt => FeedSavedSearchMapper.kt} | 12 +- .../source/FeedSavedSearchRepositoryImpl.kt | 12 +- .../{SavedSearch.kt => SavedSearchMapper.kt} | 13 +- .../data/source/SavedSearchRepositoryImpl.kt | 6 +- .../tachiyomi/data/source/SourceMapper.kt | 18 -- .../data/source/SourceRepositoryImpl.kt | 31 +- .../data/source/StubSourceRepositoryImpl.kt | 10 +- .../java/tachiyomi/data/track/TrackMapper.kt | 36 --- .../data/track/TrackRepositoryImpl.kt | 42 ++- .../tachiyomi/data/updates/UpdatesMapper.kt | 67 ----- .../data/updates/UpdatesRepositoryImpl.kt | 69 ++++- 30 files changed, 518 insertions(+), 437 deletions(-) delete mode 100644 data/src/main/java/tachiyomi/data/manga/FavoriteEntry.kt rename data/src/main/java/tachiyomi/data/manga/{MergedMangaReferenceMapper.kt => MergedMangaMapper.kt} (56%) delete mode 100644 data/src/main/java/tachiyomi/data/manga/SearchMetadataMapper.kt delete mode 100644 data/src/main/java/tachiyomi/data/manga/SearchTag.kt delete mode 100644 data/src/main/java/tachiyomi/data/manga/SearchTitle.kt rename data/src/main/java/tachiyomi/data/source/{FeedSavedSearch.kt => FeedSavedSearchMapper.kt} (52%) rename data/src/main/java/tachiyomi/data/source/{SavedSearch.kt => SavedSearchMapper.kt} (53%) delete mode 100644 data/src/main/java/tachiyomi/data/source/SourceMapper.kt delete mode 100644 data/src/main/java/tachiyomi/data/track/TrackMapper.kt delete mode 100644 data/src/main/java/tachiyomi/data/updates/UpdatesMapper.kt diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupCreator.kt b/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupCreator.kt index abae206b9..6939f1dca 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupCreator.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupCreator.kt @@ -58,7 +58,7 @@ import tachiyomi.core.preference.Preference import tachiyomi.core.preference.PreferenceStore import tachiyomi.core.util.system.logcat import tachiyomi.data.DatabaseHandler -import tachiyomi.data.manga.mangaMapper +import tachiyomi.data.manga.MangaMapper import tachiyomi.domain.backup.service.BackupPreferences import tachiyomi.domain.category.interactor.GetCategories import tachiyomi.domain.category.model.Category @@ -105,7 +105,7 @@ class BackupCreator( } val databaseManga = getFavorites.await() /* SY --> */ + if (flags and BACKUP_READ_MANGA_MASK == BACKUP_READ_MANGA) { - handler.awaitList { mangasQueries.getReadMangaNotInLibrary(mangaMapper) } + handler.awaitList { mangasQueries.getReadMangaNotInLibrary(MangaMapper::mapManga) } } else { emptyList() } + getMergedManga.await() // SY <-- diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupRestorer.kt b/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupRestorer.kt index 82ef01a15..d418a1896 100644 --- a/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupRestorer.kt +++ b/app/src/main/java/eu/kanade/tachiyomi/data/backup/BackupRestorer.kt @@ -38,8 +38,8 @@ import tachiyomi.data.Manga_sync import tachiyomi.data.Mangas import tachiyomi.data.StringListAndColumnAdapter import tachiyomi.data.UpdateStrategyColumnAdapter -import tachiyomi.data.manga.mangaMapper -import tachiyomi.data.manga.mergedMangaReferenceMapper +import tachiyomi.data.manga.MangaMapper +import tachiyomi.data.manga.MergedMangaMapper import tachiyomi.domain.category.interactor.GetCategories import tachiyomi.domain.chapter.model.Chapter import tachiyomi.domain.history.model.HistoryUpdate @@ -689,7 +689,7 @@ class BackupRestorer( */ internal suspend fun restoreMergedMangaReferencesForManga(mergeMangaId: Long, backupMergedMangaReferences: List) { // Get merged manga references from file and from db - val dbMergedMangaReferences = handler.awaitList { mergedQueries.selectAll(mergedMangaReferenceMapper) } + val dbMergedMangaReferences = handler.awaitList { mergedQueries.selectAll(MergedMangaMapper::map) } // Iterate over them backupMergedMangaReferences.forEach { backupMergedMangaReference -> @@ -697,7 +697,7 @@ class BackupRestorer( // Store the inserted id in the backupMergedMangaReference if (dbMergedMangaReferences.none { backupMergedMangaReference.mergeUrl == it.mergeUrl && backupMergedMangaReference.mangaUrl == it.mangaUrl }) { // Let the db assign the id - val mergedManga = handler.awaitOneOrNull { mangasQueries.getMangaByUrlAndSource(backupMergedMangaReference.mangaUrl, backupMergedMangaReference.mangaSourceId, mangaMapper) } ?: return@forEach + val mergedManga = handler.awaitOneOrNull { mangasQueries.getMangaByUrlAndSource(backupMergedMangaReference.mangaUrl, backupMergedMangaReference.mangaSourceId, MangaMapper::mapManga) } ?: return@forEach backupMergedMangaReference.getMergedMangaReference().run { handler.await { mergedQueries.insert( diff --git a/app/src/main/java/exh/EXHMigrations.kt b/app/src/main/java/exh/EXHMigrations.kt index e9a2af128..8a78eaffd 100644 --- a/app/src/main/java/exh/EXHMigrations.kt +++ b/app/src/main/java/exh/EXHMigrations.kt @@ -48,8 +48,8 @@ import tachiyomi.core.preference.getEnum import tachiyomi.core.preference.minusAssign import tachiyomi.core.util.system.logcat import tachiyomi.data.DatabaseHandler -import tachiyomi.data.category.categoryMapper -import tachiyomi.data.chapter.chapterMapper +import tachiyomi.data.category.CategoryMapper +import tachiyomi.data.chapter.ChapterMapper import tachiyomi.domain.backup.service.BackupPreferences import tachiyomi.domain.chapter.interactor.DeleteChapters import tachiyomi.domain.chapter.interactor.UpdateChapter @@ -184,8 +184,8 @@ object EXHMigrations { } val loadedMangaList = mangaConfigs.map { it.second.children }.flatten().mapNotNull { it.load() }.distinct() - val chapters = runBlocking { handler.awaitList { ehQueries.getChaptersByMangaIds(mergedMangas.map { it.id }, chapterMapper) } } - val mergedMangaChapters = runBlocking { handler.awaitList { ehQueries.getChaptersByMangaIds(loadedMangaList.map { it.manga.id }, chapterMapper) } } + val chapters = runBlocking { handler.awaitList { ehQueries.getChaptersByMangaIds(mergedMangas.map { it.id }, ChapterMapper::mapChapter) } } + val mergedMangaChapters = runBlocking { handler.awaitList { ehQueries.getChaptersByMangaIds(loadedMangaList.map { it.manga.id }, ChapterMapper::mapChapter) } } val mergedMangaChaptersMatched = mergedMangaChapters.mapNotNull { chapter -> loadedMangaList.firstOrNull { it.manga.id == chapter.id }?.let { it to chapter } } val parsedChapters = chapters.filter { it.read || it.lastPageRead != 0L }.mapNotNull { chapter -> readUrlConfig(chapter.url)?.let { chapter to it } } @@ -430,7 +430,7 @@ object EXHMigrations { } runBlocking { handler.await(true) { - categoriesQueries.getCategories(categoryMapper).executeAsList() + categoriesQueries.getCategories(CategoryMapper::mapCategory).executeAsList() .filter { (it.flags and 0b00111100L) == 0b00100000L } .forEach { categoriesQueries.update( diff --git a/data/src/main/java/tachiyomi/data/category/CategoryMapper.kt b/data/src/main/java/tachiyomi/data/category/CategoryMapper.kt index 37f18ae80..dc91c4535 100644 --- a/data/src/main/java/tachiyomi/data/category/CategoryMapper.kt +++ b/data/src/main/java/tachiyomi/data/category/CategoryMapper.kt @@ -2,11 +2,18 @@ package tachiyomi.data.category import tachiyomi.domain.category.model.Category -val categoryMapper: (Long, String, Long, Long) -> Category = { id, name, order, flags -> - Category( - id = id, - name = name, - order = order, - flags = flags, - ) +object CategoryMapper { + fun mapCategory( + id: Long, + name: String, + order: Long, + flags: Long, + ): Category { + return Category( + id = id, + name = name, + order = order, + flags = flags, + ) + } } diff --git a/data/src/main/java/tachiyomi/data/category/CategoryRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/category/CategoryRepositoryImpl.kt index 4915413a4..417a04e11 100644 --- a/data/src/main/java/tachiyomi/data/category/CategoryRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/category/CategoryRepositoryImpl.kt @@ -12,26 +12,26 @@ class CategoryRepositoryImpl( ) : CategoryRepository { override suspend fun get(id: Long): Category? { - return handler.awaitOneOrNull { categoriesQueries.getCategory(id, categoryMapper) } + return handler.awaitOneOrNull { categoriesQueries.getCategory(id, CategoryMapper::mapCategory) } } override suspend fun getAll(): List { - return handler.awaitList { categoriesQueries.getCategories(categoryMapper) } + return handler.awaitList { categoriesQueries.getCategories(CategoryMapper::mapCategory) } } override fun getAllAsFlow(): Flow> { - return handler.subscribeToList { categoriesQueries.getCategories(categoryMapper) } + return handler.subscribeToList { categoriesQueries.getCategories(CategoryMapper::mapCategory) } } override suspend fun getCategoriesByMangaId(mangaId: Long): List { return handler.awaitList { - categoriesQueries.getCategoriesByMangaId(mangaId, categoryMapper) + categoriesQueries.getCategoriesByMangaId(mangaId, CategoryMapper::mapCategory) } } override fun getCategoriesByMangaIdAsFlow(mangaId: Long): Flow> { return handler.subscribeToList { - categoriesQueries.getCategoriesByMangaId(mangaId, categoryMapper) + categoriesQueries.getCategoriesByMangaId(mangaId, CategoryMapper::mapCategory) } } diff --git a/data/src/main/java/tachiyomi/data/chapter/ChapterMapper.kt b/data/src/main/java/tachiyomi/data/chapter/ChapterMapper.kt index c8243682f..f17f2a833 100644 --- a/data/src/main/java/tachiyomi/data/chapter/ChapterMapper.kt +++ b/data/src/main/java/tachiyomi/data/chapter/ChapterMapper.kt @@ -2,35 +2,34 @@ package tachiyomi.data.chapter import tachiyomi.domain.chapter.model.Chapter -val chapterMapper: ( - Long, - Long, - String, - String, - String?, - Boolean, - Boolean, - Long, - Double, - Long, - Long, - Long, - Long, -) -> Chapter = - { id, mangaId, url, name, scanlator, read, bookmark, lastPageRead, chapterNumber, sourceOrder, dateFetch, dateUpload, lastModifiedAt -> - Chapter( - id = id, - mangaId = mangaId, - read = read, - bookmark = bookmark, - lastPageRead = lastPageRead, - dateFetch = dateFetch, - sourceOrder = sourceOrder, - url = url, - name = name, - dateUpload = dateUpload, - chapterNumber = chapterNumber, - scanlator = scanlator, - lastModifiedAt = lastModifiedAt, - ) - } +object ChapterMapper { + fun mapChapter( + id: Long, + mangaId: Long, + url: String, + name: String, + scanlator: String?, + read: Boolean, + bookmark: Boolean, + lastPageRead: Long, + chapterNumber: Double, + sourceOrder: Long, + dateFetch: Long, + dateUpload: Long, + lastModifiedAt: Long, + ): Chapter = Chapter( + id = id, + mangaId = mangaId, + read = read, + bookmark = bookmark, + lastPageRead = lastPageRead, + dateFetch = dateFetch, + sourceOrder = sourceOrder, + url = url, + name = name, + dateUpload = dateUpload, + chapterNumber = chapterNumber, + scanlator = scanlator, + lastModifiedAt = lastModifiedAt, + ) +} diff --git a/data/src/main/java/tachiyomi/data/chapter/ChapterRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/chapter/ChapterRepositoryImpl.kt index b95c703b2..ab2dd2ec4 100644 --- a/data/src/main/java/tachiyomi/data/chapter/ChapterRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/chapter/ChapterRepositoryImpl.kt @@ -77,27 +77,27 @@ class ChapterRepositoryImpl( } override suspend fun getChapterByMangaId(mangaId: Long): List { - return handler.awaitList { chaptersQueries.getChaptersByMangaId(mangaId, chapterMapper) } + return handler.awaitList { chaptersQueries.getChaptersByMangaId(mangaId, ChapterMapper::mapChapter) } } override suspend fun getBookmarkedChaptersByMangaId(mangaId: Long): List { return handler.awaitList { chaptersQueries.getBookmarkedChaptersByMangaId( mangaId, - chapterMapper, + ChapterMapper::mapChapter, ) } } override suspend fun getChapterById(id: Long): Chapter? { - return handler.awaitOneOrNull { chaptersQueries.getChapterById(id, chapterMapper) } + return handler.awaitOneOrNull { chaptersQueries.getChapterById(id, ChapterMapper::mapChapter) } } override suspend fun getChapterByMangaIdAsFlow(mangaId: Long): Flow> { return handler.subscribeToList { chaptersQueries.getChaptersByMangaId( mangaId, - chapterMapper, + ChapterMapper::mapChapter, ) } } @@ -107,22 +107,22 @@ class ChapterRepositoryImpl( chaptersQueries.getChapterByUrlAndMangaId( url, mangaId, - chapterMapper, + ChapterMapper::mapChapter, ) } } // SY --> override suspend fun getChapterByUrl(url: String): List { - return handler.awaitList { chaptersQueries.getChapterByUrl(url, chapterMapper) } + return handler.awaitList { chaptersQueries.getChapterByUrl(url, ChapterMapper::mapChapter) } } override suspend fun getMergedChapterByMangaId(mangaId: Long): List { - return handler.awaitList { chaptersQueries.getMergedChaptersByMangaId(mangaId, chapterMapper) } + return handler.awaitList { chaptersQueries.getMergedChaptersByMangaId(mangaId, ChapterMapper::mapChapter) } } override suspend fun getMergedChapterByMangaIdAsFlow(mangaId: Long): Flow> { - return handler.subscribeToList { chaptersQueries.getMergedChaptersByMangaId(mangaId, chapterMapper) } + return handler.subscribeToList { chaptersQueries.getMergedChaptersByMangaId(mangaId, ChapterMapper::mapChapter) } } // SY <-- } diff --git a/data/src/main/java/tachiyomi/data/history/HistoryMapper.kt b/data/src/main/java/tachiyomi/data/history/HistoryMapper.kt index 5556d56e6..32ac5f494 100644 --- a/data/src/main/java/tachiyomi/data/history/HistoryMapper.kt +++ b/data/src/main/java/tachiyomi/data/history/HistoryMapper.kt @@ -5,30 +5,32 @@ import tachiyomi.domain.history.model.HistoryWithRelations import tachiyomi.domain.manga.model.MangaCover import java.util.Date -val historyMapper: (Long, Long, Date?, Long) -> History = { id, chapterId, readAt, readDuration -> - History( +object HistoryMapper { + fun mapHistory( + id: Long, + chapterId: Long, + readAt: Date?, + readDuration: Long, + ): History = History( id = id, chapterId = chapterId, readAt = readAt, readDuration = readDuration, ) -} -val historyWithRelationsMapper: ( - Long, - Long, - Long, - String, - String?, - Long, - Boolean, - Long, - Double, - Date?, - Long, -) -> HistoryWithRelations = { - historyId, mangaId, chapterId, title, thumbnailUrl, sourceId, isFavorite, coverLastModified, chapterNumber, readAt, readDuration -> - HistoryWithRelations( + fun mapHistoryWithRelations( + historyId: Long, + mangaId: Long, + chapterId: Long, + title: String, + thumbnailUrl: String?, + sourceId: Long, + isFavorite: Boolean, + coverLastModified: Long, + chapterNumber: Double, + readAt: Date?, + readDuration: Long, + ): HistoryWithRelations = HistoryWithRelations( id = historyId, chapterId = chapterId, mangaId = mangaId, diff --git a/data/src/main/java/tachiyomi/data/history/HistoryRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/history/HistoryRepositoryImpl.kt index 0898e316a..bafb3ce5e 100644 --- a/data/src/main/java/tachiyomi/data/history/HistoryRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/history/HistoryRepositoryImpl.kt @@ -15,13 +15,13 @@ class HistoryRepositoryImpl( override fun getHistory(query: String): Flow> { return handler.subscribeToList { - historyViewQueries.history(query, historyWithRelationsMapper) + historyViewQueries.history(query, HistoryMapper::mapHistoryWithRelations) } } override suspend fun getLastHistory(): HistoryWithRelations? { return handler.awaitOneOrNull { - historyViewQueries.getLatestHistory(historyWithRelationsMapper) + historyViewQueries.getLatestHistory(HistoryMapper::mapHistoryWithRelations) } } @@ -30,7 +30,7 @@ class HistoryRepositoryImpl( } override suspend fun getHistoryByMangaId(mangaId: Long): List { - return handler.awaitList { historyQueries.getHistoryByMangaId(mangaId, historyMapper) } + return handler.awaitList { historyQueries.getHistoryByMangaId(mangaId, HistoryMapper::mapHistory) } } override suspend fun resetHistory(historyId: Long) { @@ -91,7 +91,7 @@ class HistoryRepositoryImpl( } override suspend fun getByMangaId(mangaId: Long): List { - return handler.awaitList { historyQueries.getHistoryByMangaId(mangaId, historyMapper) } + return handler.awaitList { historyQueries.getHistoryByMangaId(mangaId, HistoryMapper::mapHistory) } } // SY <-- } diff --git a/data/src/main/java/tachiyomi/data/manga/FavoriteEntry.kt b/data/src/main/java/tachiyomi/data/manga/FavoriteEntry.kt deleted file mode 100644 index e1c349afe..000000000 --- a/data/src/main/java/tachiyomi/data/manga/FavoriteEntry.kt +++ /dev/null @@ -1,15 +0,0 @@ -package tachiyomi.data.manga - -import tachiyomi.domain.manga.model.FavoriteEntry - -val favoriteEntryMapper: (String, String, String, Long, String?, String?) -> FavoriteEntry = - { gid, token, title, category, otherGid, otherToken -> - FavoriteEntry( - gid = gid, - token = token, - title = title, - category = category.toInt(), - otherGid = otherGid, - otherToken = otherToken, - ) - } diff --git a/data/src/main/java/tachiyomi/data/manga/FavoritesEntryRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/manga/FavoritesEntryRepositoryImpl.kt index e2ce6b448..5de9bd6cf 100644 --- a/data/src/main/java/tachiyomi/data/manga/FavoritesEntryRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/manga/FavoritesEntryRepositoryImpl.kt @@ -28,7 +28,7 @@ class FavoritesEntryRepositoryImpl( } override suspend fun selectAll(): List { - return handler.awaitList { eh_favoritesQueries.selectAll(favoriteEntryMapper) } + return handler.awaitList { eh_favoritesQueries.selectAll(::mapFavoriteEntry) } } override suspend fun addAlternative(favoriteEntryAlternative: FavoriteEntryAlternative) { @@ -45,4 +45,22 @@ class FavoritesEntryRepositoryImpl( logcat(LogPriority.INFO, e) } } + + private fun mapFavoriteEntry( + gid: String, + token: String, + title: String, + category: Long, + otherGid: String?, + otherToken: String?, + ): FavoriteEntry { + return FavoriteEntry( + gid = gid, + token = token, + title = title, + category = category.toInt(), + otherGid = otherGid, + otherToken = otherToken, + ) + } } diff --git a/data/src/main/java/tachiyomi/data/manga/MangaMapper.kt b/data/src/main/java/tachiyomi/data/manga/MangaMapper.kt index c459783c3..30f50b5fd 100644 --- a/data/src/main/java/tachiyomi/data/manga/MangaMapper.kt +++ b/data/src/main/java/tachiyomi/data/manga/MangaMapper.kt @@ -5,112 +5,164 @@ import tachiyomi.domain.library.model.LibraryManga import tachiyomi.domain.manga.model.Manga import tachiyomi.view.LibraryView -val mangaMapper: (Long, Long, String, String?, String?, String?, List?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long, List?, UpdateStrategy, Long, Long, Long?) -> Manga = - { id, source, url, artist, author, description, genre, title, status, thumbnailUrl, favorite, lastUpdate, nextUpdate, initialized, viewerFlags, chapterFlags, coverLastModified, dateAdded, filteredScanlators, updateStrategy, calculateInterval, lastModifiedAt, favoriteModifiedAt -> - Manga( - id = id, - source = source, - favorite = favorite, - lastUpdate = lastUpdate ?: 0, - nextUpdate = nextUpdate ?: 0, - fetchInterval = calculateInterval.toInt(), - dateAdded = dateAdded, - viewerFlags = viewerFlags, - chapterFlags = chapterFlags, - coverLastModified = coverLastModified, - url = url, - // SY --> - ogTitle = title, - ogArtist = artist, - ogAuthor = author, - ogDescription = description, - ogGenre = genre, - ogStatus = status, - // SY <-- - thumbnailUrl = thumbnailUrl, - updateStrategy = updateStrategy, - initialized = initialized, - // SY --> - filteredScanlators = filteredScanlators, - // SY <-- - lastModifiedAt = lastModifiedAt, - favoriteModifiedAt = favoriteModifiedAt, - ) - } -val libraryManga: (Long, Long, String, String?, String?, String?, List?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long, List?, UpdateStrategy, Long, Long, Long?, Long, Double, Long, Long, Long, Double, Long) -> LibraryManga = - { id, source, url, artist, author, description, genre, title, status, thumbnailUrl, favorite, lastUpdate, nextUpdate, initialized, viewerFlags, chapterFlags, coverLastModified, dateAdded, filteredScanlators, updateStrategy, calculateInterval, lastModifiedAt, favoriteModifiedAt, totalCount, readCount, latestUpload, chapterFetchedAt, lastRead, bookmarkCount, category -> - LibraryManga( - manga = mangaMapper( - id, - source, - url, - artist, - author, - description, - genre, - title, - status, - thumbnailUrl, - favorite, - lastUpdate, - nextUpdate, - initialized, - viewerFlags, - chapterFlags, - coverLastModified, - dateAdded, - // SY --> - filteredScanlators, - // SY <-- - updateStrategy, - calculateInterval, - lastModifiedAt, - favoriteModifiedAt, - ), - category = category, - totalChapters = totalCount, - readCount = readCount.toLong(), - bookmarkCount = bookmarkCount.toLong(), - latestUpload = latestUpload, - chapterFetchedAt = chapterFetchedAt, - lastRead = lastRead, - ) - } - -val libraryViewMapper: (LibraryView) -> LibraryManga = { - LibraryManga( - manga = Manga( - id = it._id, - source = it.source, - favorite = it.favorite, - lastUpdate = it.last_update ?: 0, - nextUpdate = it.next_update ?: 0, - dateAdded = it.date_added, - viewerFlags = it.viewer, - chapterFlags = it.chapter_flags, - coverLastModified = it.cover_last_modified, - url = it.url, - ogTitle = it.title, - ogArtist = it.artist, - ogAuthor = it.author, - ogDescription = it.description, - ogGenre = it.genre, - ogStatus = it.status, - thumbnailUrl = it.thumbnail_url, - updateStrategy = it.update_strategy, - initialized = it.initialized, - filteredScanlators = it.filtered_scanlators, - fetchInterval = it.calculate_interval.toInt(), - lastModifiedAt = it.last_modified_at, - favoriteModifiedAt = it.favorite_modified_at, - ), - category = it.category, - totalChapters = it.totalCount, - readCount = it.readCount.toLong(), - bookmarkCount = it.bookmarkCount.toLong(), - latestUpload = it.latestUpload, - chapterFetchedAt = it.chapterFetchedAt, - lastRead = it.lastRead, +object MangaMapper { + fun mapManga( + id: Long, + source: Long, + url: String, + artist: String?, + author: String?, + description: String?, + genre: List?, + title: String, + status: Long, + thumbnailUrl: String?, + favorite: Boolean, + lastUpdate: Long?, + nextUpdate: Long?, + initialized: Boolean, + viewerFlags: Long, + chapterFlags: Long, + coverLastModified: Long, + dateAdded: Long, + filteredScanlators: List?, + updateStrategy: UpdateStrategy, + calculateInterval: Long, + lastModifiedAt: Long, + favoriteModifiedAt: Long?, + ): Manga = Manga( + id = id, + source = source, + favorite = favorite, + lastUpdate = lastUpdate ?: 0, + nextUpdate = nextUpdate ?: 0, + fetchInterval = calculateInterval.toInt(), + dateAdded = dateAdded, + viewerFlags = viewerFlags, + chapterFlags = chapterFlags, + coverLastModified = coverLastModified, + url = url, + // SY --> + ogTitle = title, + ogArtist = artist, + ogAuthor = author, + ogDescription = description, + ogGenre = genre, + ogStatus = status, + // SY <-- + thumbnailUrl = thumbnailUrl, + updateStrategy = updateStrategy, + initialized = initialized, + // SY --> + filteredScanlators = filteredScanlators, + // SY <-- + lastModifiedAt = lastModifiedAt, + favoriteModifiedAt = favoriteModifiedAt, ) + + fun mapLibraryManga( + id: Long, + source: Long, + url: String, + artist: String?, + author: String?, + description: String?, + genre: List?, + title: String, + status: Long, + thumbnailUrl: String?, + favorite: Boolean, + lastUpdate: Long?, + nextUpdate: Long?, + initialized: Boolean, + viewerFlags: Long, + chapterFlags: Long, + coverLastModified: Long, + dateAdded: Long, + filteredScanlators: List?, + updateStrategy: UpdateStrategy, + calculateInterval: Long, + lastModifiedAt: Long, + favoriteModifiedAt: Long?, + totalCount: Long, + readCount: Double, + latestUpload: Long, + chapterFetchedAt: Long, + lastRead: Long, + bookmarkCount: Double, + category: Long, + ): LibraryManga = LibraryManga( + manga = mapManga( + id, + source, + url, + artist, + author, + description, + genre, + title, + status, + thumbnailUrl, + favorite, + lastUpdate, + nextUpdate, + initialized, + viewerFlags, + chapterFlags, + coverLastModified, + dateAdded, + // SY --> + filteredScanlators, + // SY <-- + updateStrategy, + calculateInterval, + lastModifiedAt, + favoriteModifiedAt, + ), + category = category, + totalChapters = totalCount, + readCount = readCount.toLong(), + bookmarkCount = bookmarkCount.toLong(), + latestUpload = latestUpload, + chapterFetchedAt = chapterFetchedAt, + lastRead = lastRead, + ) + + fun mapLibraryView(libraryView: LibraryView): LibraryManga { + return LibraryManga( + manga = Manga( + id = libraryView._id, + source = libraryView.source, + favorite = libraryView.favorite, + lastUpdate = libraryView.last_update ?: 0, + nextUpdate = libraryView.next_update ?: 0, + dateAdded = libraryView.date_added, + viewerFlags = libraryView.viewer, + chapterFlags = libraryView.chapter_flags, + coverLastModified = libraryView.cover_last_modified, + url = libraryView.url, + ogTitle = libraryView.title, + ogArtist = libraryView.artist, + ogAuthor = libraryView.author, + ogDescription = libraryView.description, + ogGenre = libraryView.genre, + ogStatus = libraryView.status, + thumbnailUrl = libraryView.thumbnail_url, + updateStrategy = libraryView.update_strategy, + initialized = libraryView.initialized, + filteredScanlators = libraryView.filtered_scanlators, + fetchInterval = libraryView.calculate_interval.toInt(), + lastModifiedAt = libraryView.last_modified_at, + favoriteModifiedAt = libraryView.favorite_modified_at, + ), + category = libraryView.category, + totalChapters = libraryView.totalCount, + readCount = libraryView.readCount.toLong(), + bookmarkCount = libraryView.bookmarkCount.toLong(), + latestUpload = libraryView.latestUpload, + chapterFetchedAt = libraryView.chapterFetchedAt, + lastRead = libraryView.lastRead, + ) + } } diff --git a/data/src/main/java/tachiyomi/data/manga/MangaMergeRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/manga/MangaMergeRepositoryImpl.kt index 960e41b2d..4d0ac25d9 100644 --- a/data/src/main/java/tachiyomi/data/manga/MangaMergeRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/manga/MangaMergeRepositoryImpl.kt @@ -14,27 +14,27 @@ class MangaMergeRepositoryImpl( ) : MangaMergeRepository { override suspend fun getMergedManga(): List { - return handler.awaitList { mergedQueries.selectAllMergedMangas(mangaMapper) } + return handler.awaitList { mergedQueries.selectAllMergedMangas(MangaMapper::mapManga) } } override suspend fun subscribeMergedManga(): Flow> { - return handler.subscribeToList { mergedQueries.selectAllMergedMangas(mangaMapper) } + return handler.subscribeToList { mergedQueries.selectAllMergedMangas(MangaMapper::mapManga) } } override suspend fun getMergedMangaById(id: Long): List { - return handler.awaitList { mergedQueries.selectMergedMangasById(id, mangaMapper) } + return handler.awaitList { mergedQueries.selectMergedMangasById(id, MangaMapper::mapManga) } } override suspend fun subscribeMergedMangaById(id: Long): Flow> { - return handler.subscribeToList { mergedQueries.selectMergedMangasById(id, mangaMapper) } + return handler.subscribeToList { mergedQueries.selectMergedMangasById(id, MangaMapper::mapManga) } } override suspend fun getReferencesById(id: Long): List { - return handler.awaitList { mergedQueries.selectByMergeId(id, mergedMangaReferenceMapper) } + return handler.awaitList { mergedQueries.selectByMergeId(id, MergedMangaMapper::map) } } override suspend fun subscribeReferencesById(id: Long): Flow> { - return handler.subscribeToList { mergedQueries.selectByMergeId(id, mergedMangaReferenceMapper) } + return handler.subscribeToList { mergedQueries.selectByMergeId(id, MergedMangaMapper::map) } } override suspend fun updateSettings(update: MergeMangaSettingsUpdate): Boolean { @@ -122,6 +122,6 @@ class MangaMergeRepositoryImpl( } override suspend fun getMergeMangaForDownloading(mergeId: Long): List { - return handler.awaitList { mergedQueries.selectMergedMangasForDownloadingById(mergeId, mangaMapper) } + return handler.awaitList { mergedQueries.selectMergedMangasForDownloadingById(mergeId, MangaMapper::mapManga) } } } diff --git a/data/src/main/java/tachiyomi/data/manga/MangaMetadataRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/manga/MangaMetadataRepositoryImpl.kt index aa9070bfa..a681c06bc 100644 --- a/data/src/main/java/tachiyomi/data/manga/MangaMetadataRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/manga/MangaMetadataRepositoryImpl.kt @@ -16,27 +16,27 @@ class MangaMetadataRepositoryImpl( ) : MangaMetadataRepository { override suspend fun getMetadataById(id: Long): SearchMetadata? { - return handler.awaitOneOrNull { search_metadataQueries.selectByMangaId(id, searchMetadataMapper) } + return handler.awaitOneOrNull { search_metadataQueries.selectByMangaId(id, ::searchMetadataMapper) } } override fun subscribeMetadataById(id: Long): Flow { - return handler.subscribeToOneOrNull { search_metadataQueries.selectByMangaId(id, searchMetadataMapper) } + return handler.subscribeToOneOrNull { search_metadataQueries.selectByMangaId(id, ::searchMetadataMapper) } } override suspend fun getTagsById(id: Long): List { - return handler.awaitList { search_tagsQueries.selectByMangaId(id, searchTagMapper) } + return handler.awaitList { search_tagsQueries.selectByMangaId(id, ::searchTagMapper) } } override fun subscribeTagsById(id: Long): Flow> { - return handler.subscribeToList { search_tagsQueries.selectByMangaId(id, searchTagMapper) } + return handler.subscribeToList { search_tagsQueries.selectByMangaId(id, ::searchTagMapper) } } override suspend fun getTitlesById(id: Long): List { - return handler.awaitList { search_titlesQueries.selectByMangaId(id, searchTitleMapper) } + return handler.awaitList { search_titlesQueries.selectByMangaId(id, ::searchTitleMapper) } } override fun subscribeTitlesById(id: Long): Flow> { - return handler.subscribeToList { search_titlesQueries.selectByMangaId(id, searchTitleMapper) } + return handler.subscribeToList { search_titlesQueries.selectByMangaId(id, ::searchTitleMapper) } } override suspend fun insertFlatMetadata(flatMetadata: FlatMetadata) { @@ -58,7 +58,7 @@ class MangaMetadataRepositoryImpl( } override suspend fun getExhFavoriteMangaWithMetadata(): List { - return handler.awaitList { mangasQueries.getEhMangaWithMetadata(EH_SOURCE_ID, EXH_SOURCE_ID, mangaMapper) } + return handler.awaitList { mangasQueries.getEhMangaWithMetadata(EH_SOURCE_ID, EXH_SOURCE_ID, MangaMapper::mapManga) } } override suspend fun getIdsOfFavoriteMangaWithMetadata(): List { @@ -66,6 +66,52 @@ class MangaMetadataRepositoryImpl( } override suspend fun getSearchMetadata(): List { - return handler.awaitList { search_metadataQueries.selectAll(searchMetadataMapper) } + return handler.awaitList { search_metadataQueries.selectAll(::searchMetadataMapper) } + } + + private fun searchMetadataMapper( + mangaId: Long, + uploader: String?, + extra: String, + indexedExtra: String?, + extraVersion: Long + ): SearchMetadata { + return SearchMetadata( + mangaId = mangaId, + uploader = uploader, + extra = extra, + indexedExtra = indexedExtra, + extraVersion = extraVersion.toInt(), + ) + } + + private fun searchTitleMapper( + mangaId: Long, + id: Long?, + title: String, + type: Long, + ): SearchTitle { + return SearchTitle( + mangaId = mangaId, + id = id, + title = title, + type = type.toInt(), + ) + } + + private fun searchTagMapper( + mangaId: Long, + id: Long?, + namespace: String?, + name: String, + type: Long, + ): SearchTag { + return SearchTag( + mangaId = mangaId, + id = id, + namespace = namespace, + name = name, + type = type.toInt(), + ) } } diff --git a/data/src/main/java/tachiyomi/data/manga/MangaRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/manga/MangaRepositoryImpl.kt index 843c6de52..f219d256c 100644 --- a/data/src/main/java/tachiyomi/data/manga/MangaRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/manga/MangaRepositoryImpl.kt @@ -19,11 +19,11 @@ class MangaRepositoryImpl( ) : MangaRepository { override suspend fun getMangaById(id: Long): Manga { - return handler.awaitOne { mangasQueries.getMangaById(id, mangaMapper) } + return handler.awaitOne { mangasQueries.getMangaById(id, MangaMapper::mapManga) } } override suspend fun getMangaByIdAsFlow(id: Long): Flow { - return handler.subscribeToOne { mangasQueries.getMangaById(id, mangaMapper) } + return handler.subscribeToOne { mangasQueries.getMangaById(id, MangaMapper::mapManga) } } override suspend fun getMangaByUrlAndSourceId(url: String, sourceId: Long): Manga? { @@ -31,7 +31,7 @@ class MangaRepositoryImpl( mangasQueries.getMangaByUrlAndSource( url, sourceId, - mangaMapper, + MangaMapper::mapManga, ) } } @@ -41,34 +41,34 @@ class MangaRepositoryImpl( mangasQueries.getMangaByUrlAndSource( url, sourceId, - mangaMapper, + MangaMapper::mapManga, ) } } override suspend fun getFavorites(): List { - return handler.awaitList { mangasQueries.getFavorites(mangaMapper) } + return handler.awaitList { mangasQueries.getFavorites(MangaMapper::mapManga) } } override suspend fun getLibraryManga(): List { - return handler.awaitListExecutable { (handler as AndroidDatabaseHandler).getLibraryQuery() }.map(libraryViewMapper) - // return handler.awaitList { libraryViewQueries.library(libraryManga) } + return handler.awaitListExecutable { (handler as AndroidDatabaseHandler).getLibraryQuery() }.map(MangaMapper::mapLibraryView) + // return handler.awaitList { libraryViewQueries.library(MangaMapper::mapLibraryManga) } } override fun getLibraryMangaAsFlow(): Flow> { - return handler.subscribeToList { libraryViewQueries.library(libraryManga) } + return handler.subscribeToList { libraryViewQueries.library(MangaMapper::mapLibraryManga) } // SY --> .map { getLibraryManga() } // SY <-- } override fun getFavoritesBySourceId(sourceId: Long): Flow> { - return handler.subscribeToList { mangasQueries.getFavoriteBySourceId(sourceId, mangaMapper) } + return handler.subscribeToList { mangasQueries.getFavoriteBySourceId(sourceId, MangaMapper::mapManga) } } override suspend fun getDuplicateLibraryManga(id: Long, title: String): List { return handler.awaitList { - mangasQueries.getDuplicateLibraryManga(title, id, mangaMapper) + mangasQueries.getDuplicateLibraryManga(title, id, MangaMapper::mapManga) } } @@ -180,11 +180,11 @@ class MangaRepositoryImpl( // SY --> override suspend fun getMangaBySourceId(sourceId: Long): List { - return handler.awaitList { mangasQueries.getBySource(sourceId, mangaMapper) } + return handler.awaitList { mangasQueries.getBySource(sourceId, MangaMapper::mapManga) } } override suspend fun getAll(): List { - return handler.awaitList { mangasQueries.getAll(mangaMapper) } + return handler.awaitList { mangasQueries.getAll(MangaMapper::mapManga) } } override suspend fun deleteManga(mangaId: Long) { @@ -194,7 +194,7 @@ class MangaRepositoryImpl( override suspend fun getReadMangaNotInLibrary(): List { return handler.awaitListExecutable { (handler as AndroidDatabaseHandler).getLibraryQuery("M.favorite = 0 AND C.readCount != 0") - }.map(libraryViewMapper) + }.map(MangaMapper::mapLibraryView) } // SY <-- } diff --git a/data/src/main/java/tachiyomi/data/manga/MergedMangaReferenceMapper.kt b/data/src/main/java/tachiyomi/data/manga/MergedMangaMapper.kt similarity index 56% rename from data/src/main/java/tachiyomi/data/manga/MergedMangaReferenceMapper.kt rename to data/src/main/java/tachiyomi/data/manga/MergedMangaMapper.kt index 403affdf1..019cfc56e 100644 --- a/data/src/main/java/tachiyomi/data/manga/MergedMangaReferenceMapper.kt +++ b/data/src/main/java/tachiyomi/data/manga/MergedMangaMapper.kt @@ -2,9 +2,21 @@ 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( +object MergedMangaMapper { + fun map( + id: Long, + isInfoManga: Boolean, + getChapterUpdates: Boolean, + chapterSortMode: Long, + chapterPriority: Long, + downloadChapters: Boolean, + mergeId: Long, + mergeUrl: String, + mangaId: Long?, + mangaUrl: String, + mangaSourceId: Long, + ): MergedMangaReference { + return MergedMangaReference( id = id, isInfoManga = isInfoManga, getChapterUpdates = getChapterUpdates, @@ -18,3 +30,4 @@ val mergedMangaReferenceMapper = mangaSourceId = mangaSourceId, ) } +} diff --git a/data/src/main/java/tachiyomi/data/manga/SearchMetadataMapper.kt b/data/src/main/java/tachiyomi/data/manga/SearchMetadataMapper.kt deleted file mode 100644 index 8ac0ff4f4..000000000 --- a/data/src/main/java/tachiyomi/data/manga/SearchMetadataMapper.kt +++ /dev/null @@ -1,14 +0,0 @@ -package tachiyomi.data.manga - -import exh.metadata.sql.models.SearchMetadata - -val searchMetadataMapper: (Long, String?, String, String?, Long) -> SearchMetadata = - { mangaId, uploader, extra, indexedExtra, extraVersion -> - SearchMetadata( - mangaId = mangaId, - uploader = uploader, - extra = extra, - indexedExtra = indexedExtra, - extraVersion = extraVersion.toInt(), - ) - } diff --git a/data/src/main/java/tachiyomi/data/manga/SearchTag.kt b/data/src/main/java/tachiyomi/data/manga/SearchTag.kt deleted file mode 100644 index 6445fbd08..000000000 --- a/data/src/main/java/tachiyomi/data/manga/SearchTag.kt +++ /dev/null @@ -1,14 +0,0 @@ -package tachiyomi.data.manga - -import exh.metadata.sql.models.SearchTag - -val searchTagMapper: (Long, Long, String?, String, Long) -> SearchTag = - { id, mangaId, namespace, name, type -> - SearchTag( - id = id, - mangaId = mangaId, - namespace = namespace, - name = name, - type = type.toInt(), - ) - } diff --git a/data/src/main/java/tachiyomi/data/manga/SearchTitle.kt b/data/src/main/java/tachiyomi/data/manga/SearchTitle.kt deleted file mode 100644 index d7a881583..000000000 --- a/data/src/main/java/tachiyomi/data/manga/SearchTitle.kt +++ /dev/null @@ -1,13 +0,0 @@ -package tachiyomi.data.manga - -import exh.metadata.sql.models.SearchTitle - -val searchTitleMapper: (Long, Long, String, Long) -> SearchTitle = - { id, mangaId, title, type -> - SearchTitle( - id = id, - mangaId = mangaId, - title = title, - type = type.toInt(), - ) - } diff --git a/data/src/main/java/tachiyomi/data/source/FeedSavedSearch.kt b/data/src/main/java/tachiyomi/data/source/FeedSavedSearchMapper.kt similarity index 52% rename from data/src/main/java/tachiyomi/data/source/FeedSavedSearch.kt rename to data/src/main/java/tachiyomi/data/source/FeedSavedSearchMapper.kt index 3d2019a28..e6e9334f0 100644 --- a/data/src/main/java/tachiyomi/data/source/FeedSavedSearch.kt +++ b/data/src/main/java/tachiyomi/data/source/FeedSavedSearchMapper.kt @@ -2,12 +2,18 @@ package tachiyomi.data.source import tachiyomi.domain.source.model.FeedSavedSearch -val feedSavedSearchMapper: (Long, Long, Long?, Boolean) -> FeedSavedSearch = - { id, source, savedSearch, global -> - FeedSavedSearch( +object FeedSavedSearchMapper { + fun map( + id: Long, + source: Long, + savedSearch: Long?, + global: Boolean + ): FeedSavedSearch { + return FeedSavedSearch( id = id, source = source, savedSearch = savedSearch, global = global, ) } +} diff --git a/data/src/main/java/tachiyomi/data/source/FeedSavedSearchRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/source/FeedSavedSearchRepositoryImpl.kt index 855422310..3c2152e79 100644 --- a/data/src/main/java/tachiyomi/data/source/FeedSavedSearchRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/source/FeedSavedSearchRepositoryImpl.kt @@ -11,15 +11,15 @@ class FeedSavedSearchRepositoryImpl( ) : FeedSavedSearchRepository { override suspend fun getGlobal(): List { - return handler.awaitList { feed_saved_searchQueries.selectAllGlobal(feedSavedSearchMapper) } + return handler.awaitList { feed_saved_searchQueries.selectAllGlobal(FeedSavedSearchMapper::map) } } override fun getGlobalAsFlow(): Flow> { - return handler.subscribeToList { feed_saved_searchQueries.selectAllGlobal(feedSavedSearchMapper) } + return handler.subscribeToList { feed_saved_searchQueries.selectAllGlobal(FeedSavedSearchMapper::map) } } override suspend fun getGlobalFeedSavedSearch(): List { - return handler.awaitList { feed_saved_searchQueries.selectGlobalFeedSavedSearch(savedSearchMapper) } + return handler.awaitList { feed_saved_searchQueries.selectGlobalFeedSavedSearch(SavedSearchMapper::map) } } override suspend fun countGlobal(): Long { @@ -27,15 +27,15 @@ class FeedSavedSearchRepositoryImpl( } override suspend fun getBySourceId(sourceId: Long): List { - return handler.awaitList { feed_saved_searchQueries.selectBySource(sourceId, feedSavedSearchMapper) } + return handler.awaitList { feed_saved_searchQueries.selectBySource(sourceId, FeedSavedSearchMapper::map) } } override fun getBySourceIdAsFlow(sourceId: Long): Flow> { - return handler.subscribeToList { feed_saved_searchQueries.selectBySource(sourceId, feedSavedSearchMapper) } + return handler.subscribeToList { feed_saved_searchQueries.selectBySource(sourceId, FeedSavedSearchMapper::map) } } override suspend fun getBySourceIdFeedSavedSearch(sourceId: Long): List { - return handler.awaitList { feed_saved_searchQueries.selectSourceFeedSavedSearch(sourceId, savedSearchMapper) } + return handler.awaitList { feed_saved_searchQueries.selectSourceFeedSavedSearch(sourceId, SavedSearchMapper::map) } } override suspend fun countBySourceId(sourceId: Long): Long { diff --git a/data/src/main/java/tachiyomi/data/source/SavedSearch.kt b/data/src/main/java/tachiyomi/data/source/SavedSearchMapper.kt similarity index 53% rename from data/src/main/java/tachiyomi/data/source/SavedSearch.kt rename to data/src/main/java/tachiyomi/data/source/SavedSearchMapper.kt index 4a5c775dc..1c47d5cc4 100644 --- a/data/src/main/java/tachiyomi/data/source/SavedSearch.kt +++ b/data/src/main/java/tachiyomi/data/source/SavedSearchMapper.kt @@ -2,9 +2,15 @@ package tachiyomi.data.source import tachiyomi.domain.source.model.SavedSearch -val savedSearchMapper: (Long, Long, String, String?, String?) -> SavedSearch = - { id, source, name, query, filtersJson -> - SavedSearch( +object SavedSearchMapper { + fun map( + id: Long, + source: Long, + name: String, + query: String?, + filtersJson: String? + ): SavedSearch { + return SavedSearch( id = id, source = source, name = name, @@ -12,3 +18,4 @@ val savedSearchMapper: (Long, Long, String, String?, String?) -> SavedSearch = filtersJson = filtersJson, ) } +} diff --git a/data/src/main/java/tachiyomi/data/source/SavedSearchRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/source/SavedSearchRepositoryImpl.kt index 69e71a3dc..5a29693ab 100644 --- a/data/src/main/java/tachiyomi/data/source/SavedSearchRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/source/SavedSearchRepositoryImpl.kt @@ -10,15 +10,15 @@ class SavedSearchRepositoryImpl( ) : SavedSearchRepository { override suspend fun getById(savedSearchId: Long): SavedSearch? { - return handler.awaitOneOrNull { saved_searchQueries.selectById(savedSearchId, savedSearchMapper) } + return handler.awaitOneOrNull { saved_searchQueries.selectById(savedSearchId, SavedSearchMapper::map) } } override suspend fun getBySourceId(sourceId: Long): List { - return handler.awaitList { saved_searchQueries.selectBySource(sourceId, savedSearchMapper) } + return handler.awaitList { saved_searchQueries.selectBySource(sourceId, SavedSearchMapper::map) } } override fun getBySourceIdAsFlow(sourceId: Long): Flow> { - return handler.subscribeToList { saved_searchQueries.selectBySource(sourceId, savedSearchMapper) } + return handler.subscribeToList { saved_searchQueries.selectBySource(sourceId, SavedSearchMapper::map) } } override suspend fun delete(savedSearchId: Long) { diff --git a/data/src/main/java/tachiyomi/data/source/SourceMapper.kt b/data/src/main/java/tachiyomi/data/source/SourceMapper.kt deleted file mode 100644 index 8b598152e..000000000 --- a/data/src/main/java/tachiyomi/data/source/SourceMapper.kt +++ /dev/null @@ -1,18 +0,0 @@ -package tachiyomi.data.source - -import tachiyomi.domain.source.model.Source -import tachiyomi.domain.source.model.StubSource - -val sourceMapper: (eu.kanade.tachiyomi.source.Source) -> Source = { source -> - Source( - id = source.id, - lang = source.lang, - name = source.name, - supportsLatest = false, - isStub = false, - ) -} - -val sourceDataMapper: (Long, String, String) -> StubSource = { id, lang, name -> - StubSource(id = id, lang = lang, name = name) -} diff --git a/data/src/main/java/tachiyomi/data/source/SourceRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/source/SourceRepositoryImpl.kt index 5cb7172a0..f7bad7b8f 100644 --- a/data/src/main/java/tachiyomi/data/source/SourceRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/source/SourceRepositoryImpl.kt @@ -1,6 +1,7 @@ package tachiyomi.data.source import eu.kanade.tachiyomi.source.CatalogueSource +import eu.kanade.tachiyomi.source.Source import eu.kanade.tachiyomi.source.model.FilterList import eu.kanade.tachiyomi.source.online.HttpSource import exh.source.MERGED_SOURCE_ID @@ -8,38 +9,39 @@ import exh.source.isEhBasedSource import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.map import tachiyomi.data.DatabaseHandler -import tachiyomi.domain.source.model.Source import tachiyomi.domain.source.model.SourceWithCount import tachiyomi.domain.source.model.StubSource import tachiyomi.domain.source.repository.SourcePagingSourceType import tachiyomi.domain.source.repository.SourceRepository import tachiyomi.domain.source.service.SourceManager +import tachiyomi.domain.source.model.Source as DomainSource class SourceRepositoryImpl( private val sourceManager: SourceManager, private val handler: DatabaseHandler, ) : SourceRepository { - override fun getSources(): Flow> { + override fun getSources(): Flow> { return sourceManager.catalogueSources.map { sources -> sources.map { - sourceMapper(it).copy( + mapSourceToDomainSource(it).copy( supportsLatest = it.supportsLatest, ) } } } - override fun getOnlineSources(): Flow> { + override fun getOnlineSources(): Flow> { return sourceManager.catalogueSources.map { sources -> sources .filterIsInstance() - .map(sourceMapper) + .map(::mapSourceToDomainSource) } } - override fun getSourcesWithFavoriteCount(): Flow>> { - val sourceIdWithFavoriteCount = handler.subscribeToList { mangasQueries.getSourceIdWithFavoriteCount() } + override fun getSourcesWithFavoriteCount(): Flow>> { + val sourceIdWithFavoriteCount = + handler.subscribeToList { mangasQueries.getSourceIdWithFavoriteCount() } return sourceIdWithFavoriteCount.map { sourceIdsWithCount -> sourceIdsWithCount // SY --> @@ -47,7 +49,7 @@ class SourceRepositoryImpl( // SY <-- .map { (sourceId, count) -> val source = sourceManager.getOrStub(sourceId) - val domainSource = sourceMapper(source).copy( + val domainSource = mapSourceToDomainSource(source).copy( isStub = source is StubSource, ) domainSource to count @@ -56,11 +58,12 @@ class SourceRepositoryImpl( } override fun getSourcesWithNonLibraryManga(): Flow> { - val sourceIdWithNonLibraryManga = handler.subscribeToList { mangasQueries.getSourceIdsWithNonLibraryManga() } + val sourceIdWithNonLibraryManga = + handler.subscribeToList { mangasQueries.getSourceIdsWithNonLibraryManga() } return sourceIdWithNonLibraryManga.map { sourceId -> sourceId.map { (sourceId, count) -> val source = sourceManager.getOrStub(sourceId) - val domainSource = sourceMapper(source).copy( + val domainSource = mapSourceToDomainSource(source).copy( isStub = source is StubSource, ) SourceWithCount(domainSource, count) @@ -101,4 +104,12 @@ class SourceRepositoryImpl( // SY <-- return SourceLatestPagingSource(source) } + + private fun mapSourceToDomainSource(source: Source): DomainSource = DomainSource( + id = source.id, + lang = source.lang, + name = source.name, + supportsLatest = false, + isStub = false, + ) } diff --git a/data/src/main/java/tachiyomi/data/source/StubSourceRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/source/StubSourceRepositoryImpl.kt index 9dd068139..157e1eb2f 100644 --- a/data/src/main/java/tachiyomi/data/source/StubSourceRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/source/StubSourceRepositoryImpl.kt @@ -10,14 +10,20 @@ class StubSourceRepositoryImpl( ) : StubSourceRepository { override fun subscribeAll(): Flow> { - return handler.subscribeToList { sourcesQueries.findAll(sourceDataMapper) } + return handler.subscribeToList { sourcesQueries.findAll(::mapStubSource) } } override suspend fun getStubSource(id: Long): StubSource? { - return handler.awaitOneOrNull { sourcesQueries.findOne(id, sourceDataMapper) } + return handler.awaitOneOrNull { sourcesQueries.findOne(id, ::mapStubSource) } } override suspend fun upsertStubSource(id: Long, lang: String, name: String) { handler.await { sourcesQueries.upsert(id, lang, name) } } + + private fun mapStubSource( + id: Long, + lang: String, + name: String, + ): StubSource = StubSource(id = id, lang = lang, name = name) } diff --git a/data/src/main/java/tachiyomi/data/track/TrackMapper.kt b/data/src/main/java/tachiyomi/data/track/TrackMapper.kt deleted file mode 100644 index a4a9714f6..000000000 --- a/data/src/main/java/tachiyomi/data/track/TrackMapper.kt +++ /dev/null @@ -1,36 +0,0 @@ -package tachiyomi.data.track - -import tachiyomi.domain.track.model.Track - -val trackMapper: ( - Long, - Long, - Long, - Long, - Long?, - String, - Double, - Long, - Long, - Double, - String, - Long, - Long, -) -> Track = - { id, mangaId, syncId, remoteId, libraryId, title, lastChapterRead, totalChapters, status, score, remoteUrl, startDate, finishDate -> - Track( - id = id, - mangaId = mangaId, - syncId = syncId, - remoteId = remoteId, - libraryId = libraryId, - title = title, - lastChapterRead = lastChapterRead, - totalChapters = totalChapters, - status = status, - score = score, - remoteUrl = remoteUrl, - startDate = startDate, - finishDate = finishDate, - ) - } diff --git a/data/src/main/java/tachiyomi/data/track/TrackRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/track/TrackRepositoryImpl.kt index 2df343605..e049b92c1 100644 --- a/data/src/main/java/tachiyomi/data/track/TrackRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/track/TrackRepositoryImpl.kt @@ -10,38 +10,38 @@ class TrackRepositoryImpl( ) : TrackRepository { override suspend fun getTrackById(id: Long): Track? { - return handler.awaitOneOrNull { manga_syncQueries.getTrackById(id, trackMapper) } + return handler.awaitOneOrNull { manga_syncQueries.getTrackById(id, ::mapTrack) } } // SY --> override suspend fun getTracks(): List { return handler.awaitList { - manga_syncQueries.getTracks(trackMapper) + manga_syncQueries.getTracks(::mapTrack) } } override suspend fun getTracksByMangaIds(mangaIds: List): List { return handler.awaitList { - manga_syncQueries.getTracksByMangaIds(mangaIds, trackMapper) + manga_syncQueries.getTracksByMangaIds(mangaIds, ::mapTrack) } } // SY <-- override suspend fun getTracksByMangaId(mangaId: Long): List { return handler.awaitList { - manga_syncQueries.getTracksByMangaId(mangaId, trackMapper) + manga_syncQueries.getTracksByMangaId(mangaId, ::mapTrack) } } override fun getTracksAsFlow(): Flow> { return handler.subscribeToList { - manga_syncQueries.getTracks(trackMapper) + manga_syncQueries.getTracks(::mapTrack) } } override fun getTracksByMangaIdAsFlow(mangaId: Long): Flow> { return handler.subscribeToList { - manga_syncQueries.getTracksByMangaId(mangaId, trackMapper) + manga_syncQueries.getTracksByMangaId(mangaId, ::mapTrack) } } @@ -82,4 +82,34 @@ class TrackRepositoryImpl( } } } + + private fun mapTrack( + id: Long, + mangaId: Long, + syncId: Long, + remoteId: Long, + libraryId: Long?, + title: String, + lastChapterRead: Double, + totalChapters: Long, + status: Long, + score: Double, + remoteUrl: String, + startDate: Long, + finishDate: Long, + ): Track = Track( + id = id, + mangaId = mangaId, + syncId = syncId, + remoteId = remoteId, + libraryId = libraryId, + title = title, + lastChapterRead = lastChapterRead, + totalChapters = totalChapters, + status = status, + score = score, + remoteUrl = remoteUrl, + startDate = startDate, + finishDate = finishDate, + ) } diff --git a/data/src/main/java/tachiyomi/data/updates/UpdatesMapper.kt b/data/src/main/java/tachiyomi/data/updates/UpdatesMapper.kt deleted file mode 100644 index 6ef1ae208..000000000 --- a/data/src/main/java/tachiyomi/data/updates/UpdatesMapper.kt +++ /dev/null @@ -1,67 +0,0 @@ -package tachiyomi.data.updates - -import tachiyomi.domain.manga.model.MangaCover -import tachiyomi.domain.updates.model.UpdatesWithRelations -import tachiyomi.view.UpdatesView - -val updateWithRelationMapper: ( - Long, - String, - Long, - String, - String?, - Boolean, - Boolean, - Long, - Long, - Boolean, - String?, - Long, - Long, - Long, -) -> UpdatesWithRelations = { - mangaId, mangaTitle, chapterId, chapterName, scanlator, read, bookmark, lastPageRead, sourceId, favorite, thumbnailUrl, coverLastModified, _, dateFetch -> - UpdatesWithRelations( - mangaId = mangaId, - // SY --> - ogMangaTitle = mangaTitle, - // SY <-- - chapterId = chapterId, - chapterName = chapterName, - scanlator = scanlator, - read = read, - bookmark = bookmark, - lastPageRead = lastPageRead, - sourceId = sourceId, - dateFetch = dateFetch, - coverData = MangaCover( - mangaId = mangaId, - sourceId = sourceId, - isMangaFavorite = favorite, - url = thumbnailUrl, - lastModified = coverLastModified, - ), - ) -} - -val updatesViewMapper: (UpdatesView) -> UpdatesWithRelations = { - UpdatesWithRelations( - mangaId = it.mangaId, - ogMangaTitle = it.mangaTitle, - chapterId = it.chapterId, - chapterName = it.chapterName, - scanlator = it.scanlator, - read = it.read, - bookmark = it.bookmark, - lastPageRead = it.last_page_read, - sourceId = it.source, - dateFetch = it.datefetch, - coverData = MangaCover( - mangaId = it.mangaId, - sourceId = it.source, - isMangaFavorite = it.favorite, - url = it.thumbnailUrl, - lastModified = it.coverLastModified, - ), - ) -} diff --git a/data/src/main/java/tachiyomi/data/updates/UpdatesRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/updates/UpdatesRepositoryImpl.kt index c55141625..fcf95368b 100644 --- a/data/src/main/java/tachiyomi/data/updates/UpdatesRepositoryImpl.kt +++ b/data/src/main/java/tachiyomi/data/updates/UpdatesRepositoryImpl.kt @@ -4,8 +4,10 @@ import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.map import tachiyomi.data.AndroidDatabaseHandler import tachiyomi.data.DatabaseHandler +import tachiyomi.domain.manga.model.MangaCover import tachiyomi.domain.updates.model.UpdatesWithRelations import tachiyomi.domain.updates.repository.UpdatesRepository +import tachiyomi.view.UpdatesView class UpdatesRepositoryImpl( private val databaseHandler: DatabaseHandler, @@ -21,17 +23,17 @@ class UpdatesRepositoryImpl( read = read, after = after, limit = limit, - mapper = updateWithRelationMapper, + mapper = ::mapUpdatesWithRelations, ) } } override fun subscribeAll(after: Long, limit: Long): Flow> { return databaseHandler.subscribeToList { - updatesViewQueries.getRecentUpdates(after, limit, updateWithRelationMapper) + updatesViewQueries.getRecentUpdates(after, limit, ::mapUpdatesWithRelations) }.map { databaseHandler.awaitListExecutable { (databaseHandler as AndroidDatabaseHandler).getUpdatesQuery(after, limit) } - .map(updatesViewMapper) + .map(::mapUpdatesView) } } @@ -45,8 +47,67 @@ class UpdatesRepositoryImpl( read = read, after = after, limit = limit, - mapper = updateWithRelationMapper, + mapper = ::mapUpdatesWithRelations, ) } } + + private fun mapUpdatesWithRelations( + mangaId: Long, + mangaTitle: String, + chapterId: Long, + chapterName: String, + scanlator: String?, + read: Boolean, + bookmark: Boolean, + lastPageRead: Long, + sourceId: Long, + favorite: Boolean, + thumbnailUrl: String?, + coverLastModified: Long, + dateUpload: Long, + dateFetch: Long, + ): UpdatesWithRelations = UpdatesWithRelations( + mangaId = mangaId, + // SY --> + ogMangaTitle = mangaTitle, + // SY <-- + chapterId = chapterId, + chapterName = chapterName, + scanlator = scanlator, + read = read, + bookmark = bookmark, + lastPageRead = lastPageRead, + sourceId = sourceId, + dateFetch = dateFetch, + coverData = MangaCover( + mangaId = mangaId, + sourceId = sourceId, + isMangaFavorite = favorite, + url = thumbnailUrl, + lastModified = coverLastModified, + ), + ) + + fun mapUpdatesView(updatesView: UpdatesView): UpdatesWithRelations { + return UpdatesWithRelations( + mangaId = updatesView.mangaId, + ogMangaTitle = updatesView.mangaTitle, + chapterId = updatesView.chapterId, + chapterName = updatesView.chapterName, + scanlator = updatesView.scanlator, + read = updatesView.read, + bookmark = updatesView.bookmark, + lastPageRead = updatesView.last_page_read, + sourceId = updatesView.source, + dateFetch = updatesView.datefetch, + coverData = MangaCover( + mangaId = updatesView.mangaId, + sourceId = updatesView.source, + isMangaFavorite = updatesView.favorite, + url = updatesView.thumbnailUrl, + lastModified = updatesView.coverLastModified, + ), + ) + } }