de36357da8
Co-authored-by: jobobby04 <jobobby04@gmail.com> Co-authored-by: AntsyLich <59261191+AntsyLich@users.noreply.github.com>
179 lines
6.5 KiB
Kotlin
179 lines
6.5 KiB
Kotlin
package tachiyomi.data.manga
|
|
|
|
import kotlinx.coroutines.flow.Flow
|
|
import logcat.LogPriority
|
|
import tachiyomi.core.common.util.system.logcat
|
|
import tachiyomi.data.DatabaseHandler
|
|
import tachiyomi.data.StringListColumnAdapter
|
|
import tachiyomi.data.UpdateStrategyColumnAdapter
|
|
import tachiyomi.domain.library.model.LibraryManga
|
|
import tachiyomi.domain.manga.model.Manga
|
|
import tachiyomi.domain.manga.model.MangaUpdate
|
|
import tachiyomi.domain.manga.repository.MangaRepository
|
|
import java.time.LocalDate
|
|
import java.time.ZoneId
|
|
|
|
class MangaRepositoryImpl(
|
|
private val handler: DatabaseHandler,
|
|
) : MangaRepository {
|
|
|
|
override suspend fun getMangaById(id: Long): Manga {
|
|
return handler.awaitOne { mangasQueries.getMangaById(id, MangaMapper::mapManga) }
|
|
}
|
|
|
|
override suspend fun getMangaByIdAsFlow(id: Long): Flow<Manga> {
|
|
return handler.subscribeToOne { mangasQueries.getMangaById(id, MangaMapper::mapManga) }
|
|
}
|
|
|
|
override suspend fun getMangaByUrlAndSourceId(url: String, sourceId: Long): Manga? {
|
|
return handler.awaitOneOrNull {
|
|
mangasQueries.getMangaByUrlAndSource(
|
|
url,
|
|
sourceId,
|
|
MangaMapper::mapManga,
|
|
)
|
|
}
|
|
}
|
|
|
|
override fun getMangaByUrlAndSourceIdAsFlow(url: String, sourceId: Long): Flow<Manga?> {
|
|
return handler.subscribeToOneOrNull {
|
|
mangasQueries.getMangaByUrlAndSource(
|
|
url,
|
|
sourceId,
|
|
MangaMapper::mapManga,
|
|
)
|
|
}
|
|
}
|
|
|
|
override suspend fun getFavorites(): List<Manga> {
|
|
return handler.awaitList { mangasQueries.getFavorites(MangaMapper::mapManga) }
|
|
}
|
|
|
|
override suspend fun getReadMangaNotInLibrary(): List<Manga> {
|
|
return handler.awaitList { mangasQueries.getReadMangaNotInLibrary(MangaMapper::mapManga) }
|
|
}
|
|
|
|
override suspend fun getLibraryManga(): List<LibraryManga> {
|
|
return handler.awaitList { libraryViewQueries.library(MangaMapper::mapLibraryManga) }
|
|
}
|
|
|
|
override fun getLibraryMangaAsFlow(): Flow<List<LibraryManga>> {
|
|
return handler.subscribeToList { libraryViewQueries.library(MangaMapper::mapLibraryManga) }
|
|
}
|
|
|
|
override fun getFavoritesBySourceId(sourceId: Long): Flow<List<Manga>> {
|
|
return handler.subscribeToList { mangasQueries.getFavoriteBySourceId(sourceId, MangaMapper::mapManga) }
|
|
}
|
|
|
|
override suspend fun getDuplicateLibraryManga(id: Long, title: String): List<Manga> {
|
|
return handler.awaitList {
|
|
mangasQueries.getDuplicateLibraryManga(title, id, MangaMapper::mapManga)
|
|
}
|
|
}
|
|
|
|
override suspend fun getUpcomingManga(statuses: Set<Long>): Flow<List<Manga>> {
|
|
val epochMillis = LocalDate.now().atStartOfDay(ZoneId.systemDefault()).toEpochSecond() * 1000
|
|
return handler.subscribeToList {
|
|
mangasQueries.getUpcomingManga(epochMillis, statuses, MangaMapper::mapManga)
|
|
}
|
|
}
|
|
|
|
override suspend fun resetViewerFlags(): Boolean {
|
|
return try {
|
|
handler.await { mangasQueries.resetViewerFlags() }
|
|
true
|
|
} catch (e: Exception) {
|
|
logcat(LogPriority.ERROR, e)
|
|
false
|
|
}
|
|
}
|
|
|
|
override suspend fun setMangaCategories(mangaId: Long, categoryIds: List<Long>) {
|
|
handler.await(inTransaction = true) {
|
|
mangas_categoriesQueries.deleteMangaCategoryByMangaId(mangaId)
|
|
categoryIds.map { categoryId ->
|
|
mangas_categoriesQueries.insert(mangaId, categoryId)
|
|
}
|
|
}
|
|
}
|
|
|
|
override suspend fun insert(manga: Manga): Long? {
|
|
return handler.awaitOneOrNullExecutable(inTransaction = true) {
|
|
mangasQueries.insert(
|
|
source = manga.source,
|
|
url = manga.url,
|
|
artist = manga.artist,
|
|
author = manga.author,
|
|
description = manga.description,
|
|
genre = manga.genre,
|
|
title = manga.title,
|
|
status = manga.status,
|
|
thumbnailUrl = manga.thumbnailUrl,
|
|
favorite = manga.favorite,
|
|
lastUpdate = manga.lastUpdate,
|
|
nextUpdate = manga.nextUpdate,
|
|
calculateInterval = manga.fetchInterval.toLong(),
|
|
initialized = manga.initialized,
|
|
viewerFlags = manga.viewerFlags,
|
|
chapterFlags = manga.chapterFlags,
|
|
coverLastModified = manga.coverLastModified,
|
|
dateAdded = manga.dateAdded,
|
|
updateStrategy = manga.updateStrategy,
|
|
version = manga.version,
|
|
)
|
|
mangasQueries.selectLastInsertedRowId()
|
|
}
|
|
}
|
|
|
|
override suspend fun update(update: MangaUpdate): Boolean {
|
|
return try {
|
|
partialUpdate(update)
|
|
true
|
|
} catch (e: Exception) {
|
|
logcat(LogPriority.ERROR, e)
|
|
false
|
|
}
|
|
}
|
|
|
|
override suspend fun updateAll(mangaUpdates: List<MangaUpdate>): Boolean {
|
|
return try {
|
|
partialUpdate(*mangaUpdates.toTypedArray())
|
|
true
|
|
} catch (e: Exception) {
|
|
logcat(LogPriority.ERROR, e)
|
|
false
|
|
}
|
|
}
|
|
|
|
private suspend fun partialUpdate(vararg mangaUpdates: MangaUpdate) {
|
|
handler.await(inTransaction = true) {
|
|
mangaUpdates.forEach { value ->
|
|
mangasQueries.update(
|
|
source = value.source,
|
|
url = value.url,
|
|
artist = value.artist,
|
|
author = value.author,
|
|
description = value.description,
|
|
genre = value.genre?.let(StringListColumnAdapter::encode),
|
|
title = value.title,
|
|
status = value.status,
|
|
thumbnailUrl = value.thumbnailUrl,
|
|
favorite = value.favorite,
|
|
lastUpdate = value.lastUpdate,
|
|
nextUpdate = value.nextUpdate,
|
|
calculateInterval = value.fetchInterval?.toLong(),
|
|
initialized = value.initialized,
|
|
viewer = value.viewerFlags,
|
|
chapterFlags = value.chapterFlags,
|
|
coverLastModified = value.coverLastModified,
|
|
dateAdded = value.dateAdded,
|
|
mangaId = value.id,
|
|
updateStrategy = value.updateStrategy?.let(UpdateStrategyColumnAdapter::encode),
|
|
version = value.version,
|
|
isSyncing = 0,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|