Store every date in the database as an Instant

This commit is contained in:
AntsyLich
2026-10-10 01:13:08 +06:00
parent 8972882a34
commit 44c1e1915d
68 changed files with 599 additions and 284 deletions
@@ -27,6 +27,8 @@ import tachiyomi.source.local.isLocal
import java.lang.Long.max import java.lang.Long.max
import java.util.TreeSet import java.util.TreeSet
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Instant
@Inject @Inject
class SyncChaptersWithSource( class SyncChaptersWithSource(
@@ -52,7 +54,7 @@ class SyncChaptersWithSource(
manga: Manga, manga: Manga,
source: Source, source: Source,
manualFetch: Boolean = false, manualFetch: Boolean = false,
fetchWindow: Pair<Long, Long> = Pair(0, 0), fetchWindow: ClosedRange<Instant>? = null,
): List<Chapter> { ): List<Chapter> {
if (rawSourceChapters.isEmpty() && !source.isLocal()) { if (rawSourceChapters.isEmpty() && !source.isLocal()) {
throw NoChaptersException() throw NoChaptersException()
@@ -60,7 +62,7 @@ class SyncChaptersWithSource(
val timeZone = TimeZone.currentSystemDefault() val timeZone = TimeZone.currentSystemDefault()
val now = Clock.System.now().toLocalDateTime(timeZone) val now = Clock.System.now().toLocalDateTime(timeZone)
val nowMillis = now.toInstant(timeZone).toEpochMilliseconds() val nowInstant = now.toInstant(timeZone)
val sourceChapters = rawSourceChapters val sourceChapters = rawSourceChapters
.distinctBy { it.url } .distinctBy { it.url }
@@ -80,7 +82,7 @@ class SyncChaptersWithSource(
// Used to not set upload date of older chapters // Used to not set upload date of older chapters
// to a higher value than newer chapters // to a higher value than newer chapters
var maxSeenUploadDate = 0L var maxSeenUploadDate: Instant? = null
for (sourceChapter in sourceChapters) { for (sourceChapter in sourceChapters) {
var chapter = sourceChapter var chapter = sourceChapter
@@ -102,11 +104,10 @@ class SyncChaptersWithSource(
val dbChapter = dbChaptersByUrl[chapter.url] val dbChapter = dbChaptersByUrl[chapter.url]
if (dbChapter == null) { if (dbChapter == null) {
val toAddChapter = if (chapter.dateUpload == 0L) { val toAddChapter = if (chapter.dateUpload == null) {
val altDateUpload = if (maxSeenUploadDate == 0L) nowMillis else maxSeenUploadDate chapter.copy(dateUpload = maxSeenUploadDate ?: nowInstant)
chapter.copy(dateUpload = altDateUpload)
} else { } else {
maxSeenUploadDate = max(maxSeenUploadDate, sourceChapter.dateUpload) maxSeenUploadDate = listOfNotNull(maxSeenUploadDate, sourceChapter.dateUpload).maxOrNull()
chapter chapter
} }
newChapters.add(toAddChapter) newChapters.add(toAddChapter)
@@ -132,7 +133,7 @@ class SyncChaptersWithSource(
chapterNumber = chapter.chapterNumber, chapterNumber = chapter.chapterNumber,
scanlator = chapter.scanlator, scanlator = chapter.scanlator,
sourceOrder = chapter.sourceOrder, sourceOrder = chapter.sourceOrder,
dateUpload = chapter.dateUpload.takeIf { it != 0L }, dateUpload = chapter.dateUpload,
memo = chapter.memo, memo = chapter.memo,
), ),
) )
@@ -149,7 +150,9 @@ class SyncChaptersWithSource(
// Return if there's nothing to add, delete, or update to avoid unnecessary db transactions. // Return if there's nothing to add, delete, or update to avoid unnecessary db transactions.
if (newChapters.isEmpty() && removedChapters.isEmpty() && updatedChapters.isEmpty()) { if (newChapters.isEmpty() && removedChapters.isEmpty() && updatedChapters.isEmpty()) {
if (manualFetch || manga.fetchInterval == 0 || manga.nextUpdate < fetchWindow.first) { val isNextUpdateBeforeWindow = fetchWindow != null &&
manga.nextUpdate.let { it == null || it < fetchWindow.start }
if (manualFetch || manga.fetchInterval == 0 || isNextUpdateBeforeWindow) {
updateManga.awaitUpdateFetchInterval( updateManga.awaitUpdateFetchInterval(
manga, manga,
timeZone, timeZone,
@@ -188,7 +191,7 @@ class SyncChaptersWithSource(
// Sources MUST return the chapters from most to less recent, which is common. // Sources MUST return the chapters from most to less recent, which is common.
var itemCount = newChapters.size var itemCount = newChapters.size
val toAdd = newChapters.map { toAddItem -> val toAdd = newChapters.map { toAddItem ->
var chapter = toAddItem.copy(dateFetch = nowMillis + itemCount--) var chapter = toAddItem.copy(dateFetch = nowInstant + (itemCount--).milliseconds)
if (chapter.chapterNumber in readChapterNumbers && markDuplicateAsRead) { if (chapter.chapterNumber in readChapterNumbers && markDuplicateAsRead) {
changedOrDuplicateReadUrls.add(chapter.url) changedOrDuplicateReadUrls.add(chapter.url)
@@ -2,6 +2,8 @@ package eu.kanade.domain.chapter.model
import eu.kanade.tachiyomi.data.database.models.ChapterImpl import eu.kanade.tachiyomi.data.database.models.ChapterImpl
import eu.kanade.tachiyomi.source.model.SChapter import eu.kanade.tachiyomi.source.model.SChapter
import mihon.core.common.extensions.toEpochMillisOrZero
import mihon.core.common.extensions.toInstantOrNull
import tachiyomi.domain.chapter.model.Chapter import tachiyomi.domain.chapter.model.Chapter
import eu.kanade.tachiyomi.data.database.models.Chapter as DbChapter import eu.kanade.tachiyomi.data.database.models.Chapter as DbChapter
@@ -10,7 +12,7 @@ fun Chapter.toSChapter(): SChapter {
return SChapter.create().also { return SChapter.create().also {
it.url = url it.url = url
it.name = name it.name = name
it.date_upload = dateUpload it.date_upload = dateUpload.toEpochMillisOrZero()
it.chapter_number = chapterNumber.toFloat() it.chapter_number = chapterNumber.toFloat()
it.scanlator = scanlator it.scanlator = scanlator
it.memo = memo it.memo = memo
@@ -21,7 +23,7 @@ fun Chapter.copyFromSChapter(sChapter: SChapter): Chapter {
return this.copy( return this.copy(
name = sChapter.name, name = sChapter.name,
url = sChapter.url, url = sChapter.url,
dateUpload = sChapter.date_upload, dateUpload = sChapter.date_upload.toInstantOrNull(),
chapterNumber = sChapter.chapter_number.toDouble(), chapterNumber = sChapter.chapter_number.toDouble(),
scanlator = sChapter.scanlator?.ifBlank { null }?.trim(), scanlator = sChapter.scanlator?.ifBlank { null }?.trim(),
memo = sChapter.memo, memo = sChapter.memo,
@@ -37,8 +39,8 @@ fun Chapter.toDbChapter(): DbChapter = ChapterImpl().also {
it.read = read it.read = read
it.bookmark = bookmark it.bookmark = bookmark
it.last_page_read = lastPageRead.toInt() it.last_page_read = lastPageRead.toInt()
it.date_fetch = dateFetch it.date_fetch = dateFetch.toEpochMilliseconds()
it.date_upload = dateUpload it.date_upload = dateUpload.toEpochMillisOrZero()
it.chapter_number = chapterNumber.toFloat() it.chapter_number = chapterNumber.toFloat()
it.source_order = sourceOrder.toInt() it.source_order = sourceOrder.toInt()
it.memo = memo it.memo = memo
@@ -9,6 +9,7 @@ import tachiyomi.domain.manga.model.Manga
import tachiyomi.domain.manga.model.MangaUpdate import tachiyomi.domain.manga.model.MangaUpdate
import tachiyomi.domain.manga.repository.MangaRepository import tachiyomi.domain.manga.repository.MangaRepository
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Instant
@Inject @Inject
class UpdateManga( class UpdateManga(
@@ -28,7 +29,7 @@ class UpdateManga(
manga: Manga, manga: Manga,
timeZone: TimeZone = TimeZone.currentSystemDefault(), timeZone: TimeZone = TimeZone.currentSystemDefault(),
dateTime: LocalDateTime = Clock.System.now().toLocalDateTime(timeZone), dateTime: LocalDateTime = Clock.System.now().toLocalDateTime(timeZone),
window: Pair<Long, Long> = fetchInterval.getWindow(dateTime.date, timeZone), window: ClosedRange<Instant>? = fetchInterval.getWindow(dateTime.date, timeZone),
): Boolean { ): Boolean {
return mangaRepository.update( return mangaRepository.update(
fetchInterval.withFetchInterval(manga, dateTime, timeZone, window), fetchInterval.withFetchInterval(manga, dateTime, timeZone, window),
@@ -36,20 +37,20 @@ class UpdateManga(
} }
suspend fun awaitUpdateLastUpdate(mangaId: Long): Boolean { suspend fun awaitUpdateLastUpdate(mangaId: Long): Boolean {
return mangaRepository.update(MangaUpdate(mangaId) { lastUpdate = Clock.System.now().toEpochMilliseconds() }) return mangaRepository.update(MangaUpdate(mangaId) { lastUpdate = Clock.System.now() })
} }
suspend fun awaitUpdateCoverLastModified(mangaId: Long): Boolean { suspend fun awaitUpdateCoverLastModified(mangaId: Long): Boolean {
return mangaRepository.update( return mangaRepository.update(
MangaUpdate(mangaId) { MangaUpdate(mangaId) {
coverLastModified = Clock.System.now().toEpochMilliseconds() coverLastModified = Clock.System.now()
}, },
) )
} }
suspend fun awaitUpdateFavorite(mangaId: Long, favorite: Boolean): Boolean { suspend fun awaitUpdateFavorite(mangaId: Long, favorite: Boolean): Boolean {
val update = when (favorite) { val update = when (favorite) {
true -> MangaUpdate(mangaId) { favoriteAt = Clock.System.now().toEpochMilliseconds() } true -> MangaUpdate(mangaId) { favoriteAt = Clock.System.now() }
false -> MangaUpdate(mangaId) { favoriteAt = null } false -> MangaUpdate(mangaId) { favoriteAt = null }
} }
return mangaRepository.update(update) return mangaRepository.update(update)
@@ -16,7 +16,6 @@ import tachiyomi.domain.chapter.model.Chapter
import tachiyomi.domain.manga.model.Manga import tachiyomi.domain.manga.model.Manga
import uy.kohesive.injekt.Injekt import uy.kohesive.injekt.Injekt
import uy.kohesive.injekt.api.get import uy.kohesive.injekt.api.get
import kotlin.time.Instant
// TODO: move these into the domain model // TODO: move these into the domain model
val Manga.readingMode: Long val Manga.readingMode: Long
@@ -90,11 +89,7 @@ fun getComicInfo(
categories: List<String>?, categories: List<String>?,
sourceName: String, sourceName: String,
): ComicInfo { ): ComicInfo {
val date = chapter.dateUpload val date = chapter.dateUpload?.toLocalDateTime(TimeZone.currentSystemDefault())
.takeIf { it != 0L }
?.let {
Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.currentSystemDefault())
}
return ComicInfo( return ComicInfo(
title = ComicInfo.Title(chapter.name), title = ComicInfo.Title(chapter.name),
@@ -18,6 +18,7 @@ import tachiyomi.domain.chapter.interactor.GetChaptersByMangaId
import tachiyomi.domain.history.interactor.GetHistory import tachiyomi.domain.history.interactor.GetHistory
import tachiyomi.domain.manga.model.Manga import tachiyomi.domain.manga.model.Manga
import tachiyomi.domain.track.interactor.UpsertTrack import tachiyomi.domain.track.interactor.UpsertTrack
import kotlin.time.Instant
@Inject @Inject
class AddTracks( class AddTracks(
@@ -55,18 +56,18 @@ class AddTracks(
tracker.setRemoteLastChapterRead(track.toDbTrack(), latestLocalReadChapterNumber.toInt()) tracker.setRemoteLastChapterRead(track.toDbTrack(), latestLocalReadChapterNumber.toInt())
} }
if (track.startDate <= 0) { if (track.startDate == null) {
val firstReadChapterDate = getHistory.await(mangaId) val firstReadChapterDate = getHistory.await(mangaId)
.mapNotNull { it.readAt?.takeIf { readAt -> readAt.time > 0 } } .mapNotNull { it.readAt }
.minOrNull() .minOrNull()
firstReadChapterDate?.let { firstReadChapterDate?.let {
val startDate = firstReadChapterDate.time.convertEpochMillisZone( val startDate = firstReadChapterDate.toEpochMilliseconds().convertEpochMillisZone(
TimeZone.currentSystemDefault(), TimeZone.currentSystemDefault(),
TimeZone.UTC, TimeZone.UTC,
) )
track = track.copy( track = track.copy(
startDate = startDate, startDate = Instant.fromEpochMilliseconds(startDate),
) )
tracker.setRemoteStartDate(track.toDbTrack(), startDate) tracker.setRemoteStartDate(track.toDbTrack(), startDate)
} }
@@ -1,5 +1,7 @@
package eu.kanade.domain.track.model package eu.kanade.domain.track.model
import mihon.core.common.extensions.toEpochMillisOrZero
import mihon.core.common.extensions.toInstantOrNull
import tachiyomi.domain.track.model.Track import tachiyomi.domain.track.model.Track
import eu.kanade.tachiyomi.data.database.models.Track as DbTrack import eu.kanade.tachiyomi.data.database.models.Track as DbTrack
@@ -25,8 +27,8 @@ fun Track.toDbTrack(): DbTrack = DbTrack.create(trackerId).also {
it.status = status it.status = status
it.score = score it.score = score
it.tracking_url = remoteUrl it.tracking_url = remoteUrl
it.started_reading_date = startDate it.started_reading_date = startDate.toEpochMillisOrZero()
it.finished_reading_date = finishDate it.finished_reading_date = finishDate.toEpochMillisOrZero()
it.private = private it.private = private
} }
@@ -44,8 +46,8 @@ fun DbTrack.toDomainTrack(idRequired: Boolean = true): Track? {
status = status, status = status,
score = score, score = score,
remoteUrl = tracking_url, remoteUrl = tracking_url,
startDate = started_reading_date, startDate = started_reading_date.toInstantOrNull(),
finishDate = finished_reading_date, finishDate = finished_reading_date.toInstantOrNull(),
private = private, private = private,
) )
} }
@@ -15,13 +15,10 @@ import kotlin.time.Instant
@Composable @Composable
fun relativeDateText( fun relativeDateText(
dateEpochMillis: Long, date: Instant?,
): String { ): String {
return relativeDateText( return relativeDateText(
localDate = Instant.fromEpochMilliseconds(dateEpochMillis) localDate = date?.toLocalDateTime(TimeZone.currentSystemDefault())?.date,
.toLocalDateTime(TimeZone.currentSystemDefault())
.date
.takeIf { dateEpochMillis != 0L },
) )
} }
@@ -6,12 +6,10 @@ import kotlinx.datetime.TimeZone
import kotlinx.datetime.toLocalDateTime import kotlinx.datetime.toLocalDateTime
import tachiyomi.domain.history.model.HistoryWithRelations import tachiyomi.domain.history.model.HistoryWithRelations
import tachiyomi.domain.manga.model.MangaCover import tachiyomi.domain.manga.model.MangaCover
import java.util.Date
import kotlin.random.Random import kotlin.random.Random
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Duration.Companion.days import kotlin.time.Duration.Companion.days
import kotlin.time.Instant import kotlin.time.Instant
import kotlin.time.toJavaInstant
class HistoryviewModelStateProvider : PreviewParameterProvider<HistoryViewModel.State> { class HistoryviewModelStateProvider : PreviewParameterProvider<HistoryViewModel.State> {
@@ -99,14 +97,14 @@ class HistoryviewModelStateProvider : PreviewParameterProvider<HistoryViewModel.
mangaId = Random.nextLong(), mangaId = Random.nextLong(),
title = "Test Title", title = "Test Title",
chapterNumber = Random.nextDouble(), chapterNumber = Random.nextDouble(),
readAt = Date.from(Clock.System.now().toJavaInstant()), readAt = Clock.System.now(),
readDuration = Random.nextLong(), readDuration = Random.nextLong(),
coverData = MangaCover( coverData = MangaCover(
mangaId = Random.nextLong(), mangaId = Random.nextLong(),
sourceId = Random.nextLong(), sourceId = Random.nextLong(),
isMangaFavorite = Random.nextBoolean(), isMangaFavorite = Random.nextBoolean(),
url = "https://example.com/cover.png", url = "https://example.com/cover.png",
lastModified = Random.nextLong(), lastModified = Instant.fromEpochMilliseconds(Random.nextLong()),
), ),
), ),
), ),
@@ -2,7 +2,7 @@ package eu.kanade.presentation.history.components
import androidx.compose.ui.tooling.preview.PreviewParameterProvider import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import tachiyomi.domain.history.model.HistoryWithRelations import tachiyomi.domain.history.model.HistoryWithRelations
import java.util.Date import kotlin.time.Instant
internal class HistoryWithRelationsProvider : PreviewParameterProvider<HistoryWithRelations> { internal class HistoryWithRelationsProvider : PreviewParameterProvider<HistoryWithRelations> {
@@ -12,14 +12,14 @@ internal class HistoryWithRelationsProvider : PreviewParameterProvider<HistoryWi
mangaId = 3L, mangaId = 3L,
title = "Test Title", title = "Test Title",
chapterNumber = 10.2, chapterNumber = 10.2,
readAt = Date(1697247357L), readAt = Instant.fromEpochMilliseconds(1697247357L),
readDuration = 123L, readDuration = 123L,
coverData = tachiyomi.domain.manga.model.MangaCover( coverData = tachiyomi.domain.manga.model.MangaCover(
mangaId = 3L, mangaId = 3L,
sourceId = 4L, sourceId = 4L,
isMangaFavorite = false, isMangaFavorite = false,
url = "https://example.com/cover.png", url = "https://example.com/cover.png",
lastModified = 5L, lastModified = Instant.fromEpochMilliseconds(5L),
), ),
) )
@@ -36,7 +36,7 @@ internal class HistoryWithRelationsProvider : PreviewParameterProvider<HistoryWi
sourceId = 4L, sourceId = 4L,
isMangaFavorite = false, isMangaFavorite = false,
url = "https://example.com/cover.png", url = "https://example.com/cover.png",
lastModified = 5L, lastModified = Instant.fromEpochMilliseconds(5L),
), ),
) )
@@ -46,14 +46,14 @@ internal class HistoryWithRelationsProvider : PreviewParameterProvider<HistoryWi
mangaId = 3L, mangaId = 3L,
title = "Test Title", title = "Test Title",
chapterNumber = -2.0, chapterNumber = -2.0,
readAt = Date(1697247357L), readAt = Instant.fromEpochMilliseconds(1697247357L),
readDuration = 123L, readDuration = 123L,
coverData = tachiyomi.domain.manga.model.MangaCover( coverData = tachiyomi.domain.manga.model.MangaCover(
mangaId = 3L, mangaId = 3L,
sourceId = 4L, sourceId = 4L,
isMangaFavorite = false, isMangaFavorite = false,
url = "https://example.com/cover.png", url = "https://example.com/cover.png",
lastModified = 5L, lastModified = Instant.fromEpochMilliseconds(5L),
), ),
) )
@@ -113,13 +113,13 @@ fun TrackInfoDialogHome(
onScoreClick = { onScoreClick(item) } onScoreClick = { onScoreClick(item) }
.takeIf { supportsScoring }, .takeIf { supportsScoring },
startDate = remember(item.track.startDate) { startDate = remember(item.track.startDate) {
dateFormat.format(item.track.startDate.toLocalDate().toJavaLocalDate()) item.track.startDate?.let { dateFormat.format(it.toJavaLocalDate()) }
} }
.takeIf { supportsReadingDates && item.track.startDate != 0L }, ?.takeIf { supportsReadingDates },
onStartDateClick = { onStartDateEdit(item) } // TODO onStartDateClick = { onStartDateEdit(item) } // TODO
.takeIf { supportsReadingDates }, .takeIf { supportsReadingDates },
endDate = dateFormat.format(item.track.finishDate.toJavaLocalDate()) endDate = item.track.finishDate?.let { dateFormat.format(it.toJavaLocalDate()) }
.takeIf { supportsReadingDates && item.track.finishDate != 0L }, ?.takeIf { supportsReadingDates },
onEndDateClick = { onEndDateEdit(item) } onEndDateClick = { onEndDateEdit(item) }
.takeIf { supportsReadingDates }, .takeIf { supportsReadingDates },
onNewSearch = { onNewSearch(item) }, onNewSearch = { onNewSearch(item) },
@@ -23,8 +23,8 @@ internal class TrackInfoDialogHomePreviewProvider :
status = 1L, status = 1L,
score = 2.0, score = 2.0,
remoteUrl = "https://example.com", remoteUrl = "https://example.com",
startDate = 0L, startDate = null,
finishDate = 0L, finishDate = null,
private = false, private = false,
) )
private val privateTrack = aTrack.copy(private = true) private val privateTrack = aTrack.copy(private = true)
@@ -5,13 +5,10 @@ import androidx.compose.runtime.Composable
import androidx.compose.ui.tooling.preview.PreviewParameterProvider import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import androidx.compose.ui.tooling.preview.datasource.LoremIpsum import androidx.compose.ui.tooling.preview.datasource.LoremIpsum
import eu.kanade.tachiyomi.data.track.model.TrackSearch import eu.kanade.tachiyomi.data.track.model.TrackSearch
import java.text.SimpleDateFormat import eu.kanade.tachiyomi.util.lang.toLocalDate
import java.util.Date
import java.util.Locale
import kotlin.random.Random import kotlin.random.Random
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Duration.Companion.days import kotlin.time.Duration.Companion.days
import kotlin.time.toJavaInstant
internal class TrackerSearchPreviewProvider : PreviewParameterProvider<@Composable () -> Unit> { internal class TrackerSearchPreviewProvider : PreviewParameterProvider<@Composable () -> Unit> {
private val fullPageWithSecondSelected = @Composable { private val fullPageWithSecondSelected = @Composable {
@@ -77,8 +74,6 @@ internal class TrackerSearchPreviewProvider : PreviewParameterProvider<@Composab
} }
} }
private val formatter: SimpleDateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
private fun randTrackSearch() = TrackSearch().let { private fun randTrackSearch() = TrackSearch().let {
it.id = Random.nextLong() it.id = Random.nextLong()
it.manga_id = Random.nextLong() it.manga_id = Random.nextLong()
@@ -94,7 +89,7 @@ internal class TrackerSearchPreviewProvider : PreviewParameterProvider<@Composab
it.finished_reading_date = 0L it.finished_reading_date = 0L
it.tracking_url = "https://example.com/tracker-example" it.tracking_url = "https://example.com/tracker-example"
it.cover_url = "https://example.com/cover.png" it.cover_url = "https://example.com/cover.png"
it.start_date = formatter.format(Date.from(Clock.System.now().minus((1L..365).random().days).toJavaInstant())) it.start_date = Clock.System.now().minus((1L..365).random().days).toLocalDate().toString()
it.summary = lorem((0..40).random()).joinToString() it.summary = lorem((0..40).random()).joinToString()
it.publishing_status = if (Random.nextBoolean()) "Finished" else "" it.publishing_status = if (Random.nextBoolean()) "Finished" else ""
it.publishing_type = if (Random.nextBoolean()) "Oneshot" else "" it.publishing_type = if (Random.nextBoolean()) "Oneshot" else ""
@@ -8,6 +8,7 @@ import eu.kanade.tachiyomi.data.backup.models.toBackupChapter
import eu.kanade.tachiyomi.data.backup.models.toBackupTracking import eu.kanade.tachiyomi.data.backup.models.toBackupTracking
import eu.kanade.tachiyomi.ui.reader.setting.ReadingMode import eu.kanade.tachiyomi.ui.reader.setting.ReadingMode
import mihon.core.common.extensions.toByteArray import mihon.core.common.extensions.toByteArray
import mihon.core.common.extensions.toEpochMillisOrZero
import tachiyomi.domain.category.interactor.GetCategories import tachiyomi.domain.category.interactor.GetCategories
import tachiyomi.domain.chapter.repository.ChapterRepository import tachiyomi.domain.chapter.repository.ChapterRepository
import tachiyomi.domain.history.interactor.GetHistory import tachiyomi.domain.history.interactor.GetHistory
@@ -66,7 +67,7 @@ class MangaBackupCreator(
val history = historyByMangaId.mapNotNull { history -> val history = historyByMangaId.mapNotNull { history ->
// A chapter removed since its history was read takes that history with it // A chapter removed since its history was read takes that history with it
val url = chapterUrlsById[history.chapterId] ?: return@mapNotNull null val url = chapterUrlsById[history.chapterId] ?: return@mapNotNull null
BackupHistory(url, history.readAt?.time ?: 0L, history.readDuration) BackupHistory(url, history.readAt.toEpochMillisOrZero(), history.readDuration)
} }
if (history.isNotEmpty()) { if (history.isNotEmpty()) {
mangaObject.history = history mangaObject.history = history
@@ -90,7 +91,7 @@ private fun Manga.toBackupManga() =
thumbnailUrl = this.thumbnailUrl, thumbnailUrl = this.thumbnailUrl,
favorite = this.favorite, favorite = this.favorite,
source = this.source, source = this.source,
dateAdded = this.favoriteAt ?: 0L, dateAdded = this.favoriteAt.toEpochMillisOrZero(),
viewer = (this.viewerFlags.toInt() and ReadingMode.MASK), viewer = (this.viewerFlags.toInt() and ReadingMode.MASK),
viewer_flags = this.viewerFlags.toInt(), viewer_flags = this.viewerFlags.toInt(),
chapterFlags = this.chapterFlags.toInt(), chapterFlags = this.chapterFlags.toInt(),
@@ -4,8 +4,11 @@ import kotlinx.serialization.Serializable
import kotlinx.serialization.protobuf.ProtoNumber import kotlinx.serialization.protobuf.ProtoNumber
import mihon.core.common.extensions.JsonObjectEmptyBytes import mihon.core.common.extensions.JsonObjectEmptyBytes
import mihon.core.common.extensions.toByteArray import mihon.core.common.extensions.toByteArray
import mihon.core.common.extensions.toEpochMillisOrZero
import mihon.core.common.extensions.toInstantOrNull
import mihon.core.common.extensions.toJsonObject import mihon.core.common.extensions.toJsonObject
import tachiyomi.domain.chapter.model.Chapter import tachiyomi.domain.chapter.model.Chapter
import kotlin.time.Instant
@Serializable @Serializable
class BackupChapter( class BackupChapter(
@@ -36,8 +39,8 @@ class BackupChapter(
read = this@BackupChapter.read, read = this@BackupChapter.read,
bookmark = this@BackupChapter.bookmark, bookmark = this@BackupChapter.bookmark,
lastPageRead = this@BackupChapter.lastPageRead, lastPageRead = this@BackupChapter.lastPageRead,
dateFetch = this@BackupChapter.dateFetch, dateFetch = Instant.fromEpochMilliseconds(this@BackupChapter.dateFetch),
dateUpload = this@BackupChapter.dateUpload, dateUpload = this@BackupChapter.dateUpload.toInstantOrNull(),
sourceOrder = this@BackupChapter.sourceOrder, sourceOrder = this@BackupChapter.sourceOrder,
memo = this@BackupChapter.memo.toJsonObject(), memo = this@BackupChapter.memo.toJsonObject(),
) )
@@ -52,8 +55,8 @@ fun Chapter.toBackupChapter() = BackupChapter(
read = read, read = read,
bookmark = bookmark, bookmark = bookmark,
lastPageRead = lastPageRead, lastPageRead = lastPageRead,
dateFetch = dateFetch, dateFetch = dateFetch.toEpochMilliseconds(),
dateUpload = dateUpload, dateUpload = dateUpload.toEpochMillisOrZero(),
sourceOrder = sourceOrder, sourceOrder = sourceOrder,
memo = memo.toByteArray(), memo = memo.toByteArray(),
) )
@@ -2,8 +2,8 @@ package eu.kanade.tachiyomi.data.backup.models
import kotlinx.serialization.Serializable import kotlinx.serialization.Serializable
import kotlinx.serialization.protobuf.ProtoNumber import kotlinx.serialization.protobuf.ProtoNumber
import mihon.core.common.extensions.toInstantOrNull
import tachiyomi.domain.history.model.History import tachiyomi.domain.history.model.History
import java.util.Date
@Serializable @Serializable
data class BackupHistory( data class BackupHistory(
@@ -13,7 +13,7 @@ data class BackupHistory(
) { ) {
fun getHistoryImpl(): History { fun getHistoryImpl(): History {
return History.create().copy( return History.create().copy(
readAt = Date(lastRead), readAt = lastRead.toInstantOrNull(),
readDuration = readDuration, readDuration = readDuration,
) )
} }
@@ -4,8 +4,10 @@ import eu.kanade.tachiyomi.source.model.UpdateStrategy
import kotlinx.serialization.Serializable import kotlinx.serialization.Serializable
import kotlinx.serialization.protobuf.ProtoNumber import kotlinx.serialization.protobuf.ProtoNumber
import mihon.core.common.extensions.JsonObjectEmptyBytes import mihon.core.common.extensions.JsonObjectEmptyBytes
import mihon.core.common.extensions.toInstantOrNull
import mihon.core.common.extensions.toJsonObject import mihon.core.common.extensions.toJsonObject
import tachiyomi.domain.manga.model.Manga import tachiyomi.domain.manga.model.Manga
import kotlin.time.Instant
@Suppress("DEPRECATION") @Suppress("DEPRECATION")
@Serializable @Serializable
@@ -61,9 +63,9 @@ class BackupManga(
// For libraries older than dateAdded, the favorite timestamp is the only record of when // For libraries older than dateAdded, the favorite timestamp is the only record of when
// an entry was added. It was written by a trigger in seconds, unlike dateAdded. // an entry was added. It was written by a trigger in seconds, unlike dateAdded.
favoriteAt = if (this@BackupManga.favorite) { favoriteAt = if (this@BackupManga.favorite) {
this@BackupManga.dateAdded.takeIf { it != 0L } this@BackupManga.dateAdded.toInstantOrNull()
?: this@BackupManga.favoriteModifiedAt?.times(1000) ?: this@BackupManga.favoriteModifiedAt?.let { Instant.fromEpochSeconds(it) }
?: 0L ?: Manga.UNKNOWN_FAVORITE_AT
} else { } else {
null null
}, },
@@ -2,6 +2,8 @@ package eu.kanade.tachiyomi.data.backup.models
import kotlinx.serialization.Serializable import kotlinx.serialization.Serializable
import kotlinx.serialization.protobuf.ProtoNumber import kotlinx.serialization.protobuf.ProtoNumber
import mihon.core.common.extensions.toEpochMillisOrZero
import mihon.core.common.extensions.toInstantOrNull
import tachiyomi.domain.track.model.Track import tachiyomi.domain.track.model.Track
@Serializable @Serializable
@@ -46,8 +48,8 @@ data class BackupTracking(
totalChapters = this@BackupTracking.totalChapters.toLong(), totalChapters = this@BackupTracking.totalChapters.toLong(),
score = this@BackupTracking.score.toDouble(), score = this@BackupTracking.score.toDouble(),
status = this@BackupTracking.status.toLong(), status = this@BackupTracking.status.toLong(),
startDate = this@BackupTracking.startedReadingDate, startDate = this@BackupTracking.startedReadingDate.toInstantOrNull(),
finishDate = this@BackupTracking.finishedReadingDate, finishDate = this@BackupTracking.finishedReadingDate.toInstantOrNull(),
remoteUrl = this@BackupTracking.trackingUrl, remoteUrl = this@BackupTracking.trackingUrl,
private = this@BackupTracking.private, private = this@BackupTracking.private,
) )
@@ -64,8 +66,8 @@ fun Track.toBackupTracking() = BackupTracking(
totalChapters = totalChapters.toInt(), totalChapters = totalChapters.toInt(),
score = score.toFloat(), score = score.toFloat(),
status = status.toInt(), status = status.toInt(),
startedReadingDate = startDate, startedReadingDate = startDate.toEpochMillisOrZero(),
finishedReadingDate = finishDate, finishedReadingDate = finishDate.toEpochMillisOrZero(),
trackingUrl = remoteUrl, trackingUrl = remoteUrl,
private = private, private = private,
) )
@@ -3,7 +3,9 @@
package eu.kanade.tachiyomi.data.database.models package eu.kanade.tachiyomi.data.database.models
import eu.kanade.tachiyomi.source.model.SChapter import eu.kanade.tachiyomi.source.model.SChapter
import mihon.core.common.extensions.toInstantOrNull
import java.io.Serializable import java.io.Serializable
import kotlin.time.Instant
import tachiyomi.domain.chapter.model.Chapter as DomainChapter import tachiyomi.domain.chapter.model.Chapter as DomainChapter
interface Chapter : SChapter, Serializable { interface Chapter : SChapter, Serializable {
@@ -34,11 +36,11 @@ fun Chapter.toDomainChapter(): DomainChapter? {
read = read, read = read,
bookmark = bookmark, bookmark = bookmark,
lastPageRead = last_page_read.toLong(), lastPageRead = last_page_read.toLong(),
dateFetch = date_fetch, dateFetch = Instant.fromEpochMilliseconds(date_fetch),
sourceOrder = source_order.toLong(), sourceOrder = source_order.toLong(),
url = url, url = url,
name = name, name = name,
dateUpload = date_upload, dateUpload = date_upload.toInstantOrNull(),
chapterNumber = chapter_number.toDouble(), chapterNumber = chapter_number.toDouble(),
scanlator = scanlator, scanlator = scanlator,
memo = memo, memo = memo,
@@ -76,6 +76,7 @@ import kotlin.concurrent.atomics.AtomicInt
import kotlin.concurrent.atomics.ExperimentalAtomicApi import kotlin.concurrent.atomics.ExperimentalAtomicApi
import kotlin.concurrent.atomics.incrementAndFetch import kotlin.concurrent.atomics.incrementAndFetch
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Instant
@OptIn(ExperimentalAtomicApi::class) @OptIn(ExperimentalAtomicApi::class)
class LibraryUpdateWorker(private val context: Context, workerParams: WorkerParameters) : class LibraryUpdateWorker(private val context: Context, workerParams: WorkerParameters) :
@@ -181,10 +182,10 @@ class LibraryUpdateWorker(private val context: Context, workerParams: WorkerPara
val restrictions = libraryPreferences.autoUpdateMangaRestrictions.get() val restrictions = libraryPreferences.autoUpdateMangaRestrictions.get()
val skippedUpdates = mutableListOf<Pair<Manga, String?>>() val skippedUpdates = mutableListOf<Pair<Manga, String?>>()
val timeZone = TimeZone.currentSystemDefault() val timeZone = TimeZone.currentSystemDefault()
val (_, fetchWindowUpperBound) = fetchInterval.getWindow( val fetchWindowUpperBound = fetchInterval.getWindow(
Clock.System.now().toLocalDateTime(timeZone).date, Clock.System.now().toLocalDateTime(timeZone).date,
timeZone, timeZone,
) ).endInclusive
mangaToUpdate = listToUpdate mangaToUpdate = listToUpdate
.filter { .filter {
@@ -214,7 +215,8 @@ class LibraryUpdateWorker(private val context: Context, workerParams: WorkerPara
false false
} }
MANGA_OUTSIDE_RELEASE_PERIOD in restrictions && it.manga.nextUpdate > fetchWindowUpperBound -> { MANGA_OUTSIDE_RELEASE_PERIOD in restrictions &&
it.manga.nextUpdate.let { next -> next != null && next > fetchWindowUpperBound } -> {
skippedUpdates.add( skippedUpdates.add(
it.manga to context.stringResource(MR.strings.skipped_reason_not_in_release_period), it.manga to context.stringResource(MR.strings.skipped_reason_not_in_release_period),
) )
@@ -344,7 +346,7 @@ class LibraryUpdateWorker(private val context: Context, workerParams: WorkerPara
* @param manga the manga to update. * @param manga the manga to update.
* @return a pair of the inserted and removed chapters. * @return a pair of the inserted and removed chapters.
*/ */
private suspend fun updateManga(manga: Manga, fetchWindow: Pair<Long, Long>): List<Chapter> { private suspend fun updateManga(manga: Manga, fetchWindow: ClosedRange<Instant>): List<Chapter> {
val source = sourceManager.getOrStub(manga.source) val source = sourceManager.getOrStub(manga.source)
val update = updateMangaFromRemote( val update = updateMangaFromRemote(
@@ -244,7 +244,7 @@ class BrowseSourceViewModel(
} else { } else {
setMangaDefaultChapterFlags.await(manga) setMangaDefaultChapterFlags.await(manga)
addTracks.bindEnhancedTrackers(manga, sourceManager.getOrStub(manga.source)) addTracks.bindEnhancedTrackers(manga, sourceManager.getOrStub(manga.source))
MangaUpdate(manga.id) { favoriteAt = Clock.System.now().toEpochMilliseconds() } MangaUpdate(manga.id) { favoriteAt = Clock.System.now() }
} }
updateManga.await(update) updateManga.await(update)
@@ -164,7 +164,7 @@ class DownloadQueueViewModel(
downloadManager.cancelQueuedDownloads(downloads) downloadManager.cancelQueuedDownloads(downloads)
} }
fun <R : Comparable<R>> reorderQueue(selector: (DownloadItem) -> R, reverse: Boolean = false) { fun <R : Comparable<R>> reorderQueue(selector: (DownloadItem) -> R?, reverse: Boolean = false) {
val adapter = adapter ?: return val adapter = adapter ?: return
val newDownloads = mutableListOf<Download>() val newDownloads = mutableListOf<Download>()
adapter.headerItems.forEach { headerItem -> adapter.headerItems.forEach { headerItem ->
@@ -104,8 +104,8 @@ class HistoryViewModel(
private fun List<HistoryWithRelations>.toHistoryUiModels(): List<HistoryUiModel> { private fun List<HistoryWithRelations>.toHistoryUiModels(): List<HistoryUiModel> {
return map { HistoryUiModel.Item(it) } return map { HistoryUiModel.Item(it) }
.insertSeparators { before, after -> .insertSeparators { before, after ->
val beforeDate = before?.item?.readAt?.time?.toLocalDate() val beforeDate = before?.item?.readAt?.toLocalDate()
val afterDate = after?.item?.readAt?.time?.toLocalDate() val afterDate = after?.item?.readAt?.toLocalDate()
when { when {
beforeDate != afterDate && afterDate != null -> HistoryUiModel.Header(afterDate) beforeDate != afterDate && afterDate != null -> HistoryUiModel.Header(afterDate)
// Return null to avoid adding a separator between two items. // Return null to avoid adding a separator between two items.
@@ -325,10 +325,10 @@ class LibraryViewModel(
sortAlphabetically(manga1, manga2) sortAlphabetically(manga1, manga2)
} }
LibrarySort.Type.LastRead -> { LibrarySort.Type.LastRead -> {
manga1.libraryManga.lastRead.compareTo(manga2.libraryManga.lastRead) compareValues(manga1.libraryManga.lastRead, manga2.libraryManga.lastRead)
} }
LibrarySort.Type.LastUpdate -> { LibrarySort.Type.LastUpdate -> {
manga1.libraryManga.manga.lastUpdate.compareTo(manga2.libraryManga.manga.lastUpdate) compareValues(manga1.libraryManga.manga.lastUpdate, manga2.libraryManga.manga.lastUpdate)
} }
LibrarySort.Type.UnreadCount -> when { LibrarySort.Type.UnreadCount -> when {
// Ensure unread content comes first // Ensure unread content comes first
@@ -341,10 +341,10 @@ class LibraryViewModel(
manga1.libraryManga.totalChapters.compareTo(manga2.libraryManga.totalChapters) manga1.libraryManga.totalChapters.compareTo(manga2.libraryManga.totalChapters)
} }
LibrarySort.Type.LatestChapter -> { LibrarySort.Type.LatestChapter -> {
manga1.libraryManga.latestUpload.compareTo(manga2.libraryManga.latestUpload) compareValues(manga1.libraryManga.latestUpload, manga2.libraryManga.latestUpload)
} }
LibrarySort.Type.ChapterFetchDate -> { LibrarySort.Type.ChapterFetchDate -> {
manga1.libraryManga.chapterFetchedAt.compareTo(manga2.libraryManga.chapterFetchedAt) compareValues(manga1.libraryManga.chapterFetchedAt, manga2.libraryManga.chapterFetchedAt)
} }
LibrarySort.Type.DateAdded -> { LibrarySort.Type.DateAdded -> {
compareValues(manga1.libraryManga.manga.favoriteAt, manga2.libraryManga.manga.favoriteAt) compareValues(manga1.libraryManga.manga.favoriteAt, manga2.libraryManga.manga.favoriteAt)
@@ -501,15 +501,15 @@ data class TrackDateSelectorScreen(
// Disallow future dates // Disallow future dates
if (targetDate > Clock.System.now().toLocalDateTime(TimeZone.UTC)) return false if (targetDate > Clock.System.now().toLocalDateTime(TimeZone.UTC)) return false
val finishDate = track.finishDate?.toLocalDateTime(TimeZone.UTC)
val startDate = track.startDate?.toLocalDateTime(TimeZone.UTC)
return when { return when {
// Disallow setting start date after finish date // Disallow setting start date after finish date
start && track.finishDate > 0 -> { start && finishDate != null -> {
val finishDate = Instant.fromEpochMilliseconds(track.finishDate).toLocalDateTime(TimeZone.UTC)
targetDate <= finishDate targetDate <= finishDate
} }
// Disallow setting finish date before start date // Disallow setting finish date before start date
!start && track.startDate > 0 -> { !start && startDate != null -> {
val startDate = Instant.fromEpochMilliseconds(track.startDate).toLocalDateTime(TimeZone.UTC)
startDate <= targetDate startDate <= targetDate
} }
else -> { else -> {
@@ -522,15 +522,15 @@ data class TrackDateSelectorScreen(
// Disallow future years // Disallow future years
if (year > Clock.System.now().toLocalDateTime(TimeZone.UTC).year) return false if (year > Clock.System.now().toLocalDateTime(TimeZone.UTC).year) return false
val finishDate = track.finishDate?.toLocalDateTime(TimeZone.UTC)
val startDate = track.startDate?.toLocalDateTime(TimeZone.UTC)
return when { return when {
// Disallow setting start year after finish year // Disallow setting start year after finish year
start && track.finishDate > 0 -> { start && finishDate != null -> {
val finishDate = Instant.fromEpochMilliseconds(track.finishDate).toLocalDateTime(TimeZone.UTC)
year <= finishDate.year year <= finishDate.year
} }
// Disallow setting finish year before start year // Disallow setting finish year before start year
!start && track.startDate > 0 -> { !start && startDate != null -> {
val startDate = Instant.fromEpochMilliseconds(track.startDate).toLocalDateTime(TimeZone.UTC)
startDate.year <= year startDate.year <= year
} }
else -> { else -> {
@@ -548,9 +548,9 @@ data class TrackDateSelectorScreen(
} }
val canRemove = if (start) { val canRemove = if (start) {
track.startDate > 0 track.startDate != null
} else { } else {
track.finishDate > 0 track.finishDate != null
} }
TrackDateSelector( TrackDateSelector(
title = if (start) { title = if (start) {
@@ -589,10 +589,8 @@ data class TrackDateSelectorScreen(
// In UTC // In UTC
val initialSelection: Long val initialSelection: Long
get() { get() {
val millis = (if (start) track.startDate else track.finishDate) val date = (if (start) track.startDate else track.finishDate) ?: Clock.System.now()
.takeIf { it != 0L } return date.toEpochMilliseconds().convertEpochMillisZone(TimeZone.currentSystemDefault(), TimeZone.UTC)
?: Clock.System.now().toEpochMilliseconds()
return millis.convertEpochMillisZone(TimeZone.currentSystemDefault(), TimeZone.UTC)
} }
// In UTC // In UTC
@@ -90,8 +90,8 @@ import tachiyomi.domain.manga.model.Manga
import tachiyomi.domain.source.service.SourceManager import tachiyomi.domain.source.service.SourceManager
import tachiyomi.source.local.image.LocalCoverManager import tachiyomi.source.local.image.LocalCoverManager
import tachiyomi.source.local.isLocal import tachiyomi.source.local.isLocal
import java.util.Date
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Instant
/** /**
* Presenter used by the activity to perform background operations. * Presenter used by the activity to perform background operations.
@@ -187,7 +187,7 @@ class ReaderViewModel(
/** /**
* The time the chapter was started reading * The time the chapter was started reading
*/ */
private var chapterReadStartTime: Long? = null private var chapterReadStartTime: Instant? = null
private var chapterToDownload: Download? = null private var chapterToDownload: Download? = null
@@ -638,7 +638,7 @@ class ReaderViewModel(
} }
fun restartReadTimer() { fun restartReadTimer() {
chapterReadStartTime = Clock.System.now().toEpochMilliseconds() chapterReadStartTime = Clock.System.now()
} }
/** /**
@@ -649,8 +649,8 @@ class ReaderViewModel(
if (incognitoMode) return@let if (incognitoMode) return@let
val chapterId = readerChapter.chapter.id!! val chapterId = readerChapter.chapter.id!!
val endTime = Date() val endTime = Clock.System.now()
val sessionReadDuration = chapterReadStartTime?.let { endTime.time - it } ?: 0 val sessionReadDuration = chapterReadStartTime?.let { (endTime - it).inWholeMilliseconds } ?: 0
chapterReadStartTime = null chapterReadStartTime = null
upsertHistory.await(HistoryUpdate(chapterId, endTime, sessionReadDuration)) upsertHistory.await(HistoryUpdate(chapterId, endTime, sessionReadDuration))
@@ -12,7 +12,7 @@ import kotlin.time.Clock
fun Manga.removeCovers(coverCache: CoverCache): Manga { fun Manga.removeCovers(coverCache: CoverCache): Manga {
if (isLocal()) return this if (isLocal()) return this
return if (coverCache.deleteFromCache(this, true) > 0) { return if (coverCache.deleteFromCache(this, true) > 0) {
copy(coverLastModified = Clock.System.now().toEpochMilliseconds()) copy(coverLastModified = Clock.System.now())
} else { } else {
this this
} }
@@ -12,10 +12,8 @@ import kotlinx.datetime.toLocalDateTime
import tachiyomi.core.common.i18n.pluralStringResource import tachiyomi.core.common.i18n.pluralStringResource
import tachiyomi.core.common.i18n.stringResource import tachiyomi.core.common.i18n.stringResource
import tachiyomi.i18n.MR import tachiyomi.i18n.MR
import java.text.DateFormat
import java.time.format.DateTimeFormatter import java.time.format.DateTimeFormatter
import java.time.format.FormatStyle import java.time.format.FormatStyle
import java.util.Date
import kotlin.math.absoluteValue import kotlin.math.absoluteValue
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Instant import kotlin.time.Instant
@@ -27,8 +25,9 @@ fun LocalDateTime.toDateTimestampString(dateTimeFormatter: DateTimeFormatter): S
return "$date $time" return "$date $time"
} }
fun Date.toTimestampString(): String { fun Instant.toTimestampString(): String {
return DateFormat.getTimeInstance(DateFormat.SHORT).format(this) return DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)
.format(toLocalDateTime(TimeZone.currentSystemDefault()).toJavaLocalDateTime())
} }
fun Long.convertEpochMillisZone( fun Long.convertEpochMillisZone(
@@ -42,10 +41,14 @@ fun Long.convertEpochMillisZone(
} }
fun Long.toLocalDate(): LocalDate { fun Long.toLocalDate(): LocalDate {
return Instant.fromEpochMilliseconds(this).toLocalDateTime(TimeZone.currentSystemDefault()).date return Instant.fromEpochMilliseconds(this).toLocalDate()
} }
fun Long.toJavaLocalDate(): java.time.LocalDate { fun Instant.toLocalDate(): LocalDate {
return toLocalDateTime(TimeZone.currentSystemDefault()).date
}
fun Instant.toJavaLocalDate(): java.time.LocalDate {
return this.toLocalDate().toJavaLocalDate() return this.toLocalDate().toJavaLocalDate()
} }
@@ -115,7 +115,7 @@ class MigrateMangaUseCase(
} }
.takeIf { replace } .takeIf { replace }
val targetMangaUpdate = MangaUpdate(target.id) { val targetMangaUpdate = MangaUpdate(target.id) {
favoriteAt = current.favoriteAt?.takeIf { replace } ?: Clock.System.now().toEpochMilliseconds() favoriteAt = current.favoriteAt?.takeIf { replace } ?: Clock.System.now()
chapterFlags = current.chapterFlags chapterFlags = current.chapterFlags
viewerFlags = current.viewerFlags viewerFlags = current.viewerFlags
if (MigrationFlag.NOTES in flags) notes = current.notes if (MigrationFlag.NOTES in flags) notes = current.notes
@@ -22,6 +22,7 @@ import tachiyomi.domain.manga.repository.MangaRepository
import tachiyomi.domain.source.service.SourceManager import tachiyomi.domain.source.service.SourceManager
import tachiyomi.source.local.isLocal import tachiyomi.source.local.isLocal
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Instant
@Inject @Inject
class UpdateMangaFromRemote( class UpdateMangaFromRemote(
@@ -38,7 +39,7 @@ class UpdateMangaFromRemote(
fetchDetails: Boolean = false, fetchDetails: Boolean = false,
fetchChapters: Boolean = false, fetchChapters: Boolean = false,
manualFetch: Boolean = false, manualFetch: Boolean = false,
fetchWindow: Pair<Long, Long> = Pair(0, 0), fetchWindow: ClosedRange<Instant>? = null,
): Result<RemoteMangaUpdate> { ): Result<RemoteMangaUpdate> {
val source = sourceManager.getOrStub(manga.source) val source = sourceManager.getOrStub(manga.source)
return invoke( return invoke(
@@ -56,7 +57,7 @@ class UpdateMangaFromRemote(
fetchDetails: Boolean = false, fetchDetails: Boolean = false,
fetchChapters: Boolean = false, fetchChapters: Boolean = false,
manualFetch: Boolean = false, manualFetch: Boolean = false,
fetchWindow: Pair<Long, Long> = Pair(0, 0), fetchWindow: ClosedRange<Instant>? = null,
): Result<RemoteMangaUpdate> { ): Result<RemoteMangaUpdate> {
return try { return try {
val chapters = chapterRepository.getChapterByMangaId(manga.id) val chapters = chapterRepository.getChapterByMangaId(manga.id)
@@ -110,14 +111,14 @@ class UpdateMangaFromRemote(
// Never refresh covers if the url is empty to avoid "losing" existing covers // Never refresh covers if the url is empty to avoid "losing" existing covers
remoteManga.thumbnail_url.isNullOrEmpty() -> null remoteManga.thumbnail_url.isNullOrEmpty() -> null
!manualFetch && localManga.thumbnailUrl == remoteManga.thumbnail_url -> null !manualFetch && localManga.thumbnailUrl == remoteManga.thumbnail_url -> null
localManga.isLocal() -> Clock.System.now().toEpochMilliseconds() localManga.isLocal() -> Clock.System.now()
localManga.hasCustomCover(coverCache) -> { localManga.hasCustomCover(coverCache) -> {
coverCache.deleteFromCache(localManga, false) coverCache.deleteFromCache(localManga, false)
null null
} }
else -> { else -> {
coverCache.deleteFromCache(localManga, false) coverCache.deleteFromCache(localManga, false)
Clock.System.now().toEpochMilliseconds() Clock.System.now()
} }
} }
@@ -108,9 +108,9 @@ private fun FieldQueryNode.matches(item: LibraryItem): Boolean {
private fun ComparisonQueryNode.matches(item: LibraryItem): Boolean { private fun ComparisonQueryNode.matches(item: LibraryItem): Boolean {
val manga = item.libraryManga.manga val manga = item.libraryManga.manga
fun compareDates(timestamp: Long, value: String): Boolean? { fun compareDates(date: Instant, value: String): Boolean? {
val inputDate = runCatching { LocalDate.parse(value) }.getOrNull() ?: return null val inputDate = runCatching { LocalDate.parse(value) }.getOrNull() ?: return null
val mangaDate = Instant.fromEpochMilliseconds(timestamp).toLocalDateTime(TimeZone.currentSystemDefault()).date val mangaDate = date.toLocalDateTime(TimeZone.currentSystemDefault()).date
return queryComparator.apply(mangaDate, inputDate) return queryComparator.apply(mangaDate, inputDate)
} }
@@ -122,7 +122,7 @@ private fun ComparisonQueryNode.matches(item: LibraryItem): Boolean {
ComparisonField.FETCH_INTERVAL -> value.toIntOrNull() ComparisonField.FETCH_INTERVAL -> value.toIntOrNull()
?.let { queryComparator.apply(abs(manga.fetchInterval), it) } ?.let { queryComparator.apply(abs(manga.fetchInterval), it) }
ComparisonField.NEXT_UPDATE -> compareDates(manga.nextUpdate, value) ComparisonField.NEXT_UPDATE -> manga.nextUpdate?.let { compareDates(it, value) }
ComparisonField.UNREAD -> { ComparisonField.UNREAD -> {
value.toLongOrNull()?.let { value.toLongOrNull()?.let {
@@ -0,0 +1,14 @@
package mihon.core.common.extensions
import kotlin.time.Instant
/**
* Reads epoch milliseconds from a format that writes 0 for a time it doesn't know, such as the source API, a tracker
* or a backup.
*/
fun Long.toInstantOrNull(): Instant? = takeIf { it != 0L }?.let(Instant::fromEpochMilliseconds)
/**
* Writes epoch milliseconds to a format that takes 0 for a time it doesn't know.
*/
fun Instant?.toEpochMillisOrZero(): Long = this?.toEpochMilliseconds() ?: 0L
@@ -5,11 +5,11 @@ import eu.kanade.tachiyomi.source.model.UpdateStrategy
import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonObject
import mihon.core.common.extensions.toByteArray import mihon.core.common.extensions.toByteArray
import mihon.core.common.extensions.toJsonObject import mihon.core.common.extensions.toJsonObject
import java.util.Date import kotlin.time.Instant
object DateColumnAdapter : ColumnAdapter<Date, Long> { object InstantColumnAdapter : ColumnAdapter<Instant, Long> {
override fun decode(databaseValue: Long): Date = Date(databaseValue) override fun decode(databaseValue: Long): Instant = Instant.fromEpochMilliseconds(databaseValue)
override fun encode(value: Date): Long = value.time override fun encode(value: Instant): Long = value.toEpochMilliseconds()
} }
private const val LIST_OF_STRINGS_SEPARATOR = ", " private const val LIST_OF_STRINGS_SEPARATOR = ", "
@@ -67,15 +67,25 @@ object DatabaseBindings {
return Database( return Database(
driver = driver, driver = driver,
historyAdapter = History.Adapter( historyAdapter = History.Adapter(
read_atAdapter = DateColumnAdapter, read_atAdapter = InstantColumnAdapter,
), ),
mangaAdapter = Manga.Adapter( mangaAdapter = Manga.Adapter(
remote_genreAdapter = StringListColumnAdapter, remote_genreAdapter = StringListColumnAdapter,
remote_update_strategyAdapter = UpdateStrategyColumnAdapter, remote_update_strategyAdapter = UpdateStrategyColumnAdapter,
remote_memoAdapter = MemoColumnAdapter, remote_memoAdapter = MemoColumnAdapter,
user_favorite_atAdapter = InstantColumnAdapter,
state_chapter_last_updateAdapter = InstantColumnAdapter,
state_chapter_next_updateAdapter = InstantColumnAdapter,
state_cover_last_modifiedAdapter = InstantColumnAdapter,
), ),
chapterAdapter = Chapter.Adapter( chapterAdapter = Chapter.Adapter(
remote_date_uploadAdapter = InstantColumnAdapter,
remote_memoAdapter = MemoColumnAdapter, remote_memoAdapter = MemoColumnAdapter,
state_date_fetchAdapter = InstantColumnAdapter,
),
manga_trackAdapter = Manga_track.Adapter(
start_dateAdapter = InstantColumnAdapter,
finish_dateAdapter = InstantColumnAdapter,
), ),
) )
} }
@@ -21,8 +21,8 @@ import tachiyomi.domain.manga.model.MangaUpdate
import tachiyomi.domain.manga.repository.MangaRepository import tachiyomi.domain.manga.repository.MangaRepository
import tachiyomi.domain.track.model.Track import tachiyomi.domain.track.model.Track
import tachiyomi.domain.track.repository.TrackRepository import tachiyomi.domain.track.repository.TrackRepository
import java.util.Date
import kotlin.math.max import kotlin.math.max
import kotlin.time.Instant
@Inject @Inject
@SingleIn(AppScope::class) @SingleIn(AppScope::class)
@@ -74,7 +74,10 @@ class RestoreRepositoryImpl(
val details = if (dbManga.initialized || !manga.initialized) dbManga else manga val details = if (dbManga.initialized || !manga.initialized) dbManga else manga
return dbManga.copy( return dbManga.copy(
favoriteAt = if (dbManga.favorite || manga.favorite) { favoriteAt = if (dbManga.favorite || manga.favorite) {
listOfNotNull(dbManga.favoriteAt, manga.favoriteAt).filter { it > 0 }.minOrNull() ?: 0L listOfNotNull(dbManga.favoriteAt, manga.favoriteAt)
.filter { it > Manga.UNKNOWN_FAVORITE_AT }
.minOrNull()
?: Manga.UNKNOWN_FAVORITE_AT
} else { } else {
null null
}, },
@@ -128,7 +131,7 @@ class RestoreRepositoryImpl(
remoteStatus = manga.status, remoteStatus = manga.status,
remoteCover = manga.thumbnailUrl, remoteCover = manga.thumbnailUrl,
stateChapterLastUpdate = manga.lastUpdate, stateChapterLastUpdate = manga.lastUpdate,
stateChapterNextUpdate = 0L, stateChapterNextUpdate = null,
stateChapterFetchInterval = 0L, stateChapterFetchInterval = 0L,
stateInitialized = manga.initialized, stateInitialized = manga.initialized,
userReaderFlags = manga.viewerFlags, userReaderFlags = manga.viewerFlags,
@@ -212,7 +215,7 @@ class RestoreRepositoryImpl(
} }
private fun Chapter.forComparison() = private fun Chapter.forComparison() =
this.copy(id = 0L, mangaId = 0L, dateFetch = 0L, dateUpload = 0L) this.copy(id = 0L, mangaId = 0L, dateFetch = Instant.DISTANT_PAST, dateUpload = null)
private suspend fun restoreHistory(manga: Manga, restoredHistory: List<RestoredHistory>) { private suspend fun restoreHistory(manga: Manga, restoredHistory: List<RestoredHistory>) {
if (restoredHistory.isEmpty()) return if (restoredHistory.isEmpty()) return
@@ -229,17 +232,16 @@ class RestoreRepositoryImpl(
// each copy; they are one chapter now, read as late as any copy and for as long as all // each copy; they are one chapter now, read as late as any copy and for as long as all
.groupBy { chapterIdsByUrl.getValue(it.chapterUrl) } .groupBy { chapterIdsByUrl.getValue(it.chapterUrl) }
.map { (chapterId, copies) -> .map { (chapterId, copies) ->
val readAt = copies.maxOf { it.readAt?.time ?: 0L } val readAt = copies.mapNotNull { it.readAt }.maxOrNull()
val readDuration = copies.sumOf { it.readDuration } val readDuration = copies.sumOf { it.readDuration }
val dbHistory = dbHistoryByChapterId[chapterId] val dbHistory = dbHistoryByChapterId[chapterId]
// New history entry // New history entry
?: return@map Triple(chapterId, Date(readAt), readDuration) ?: return@map Triple(chapterId, readAt, readDuration)
// Update history entry. 0 is kept rather than written as NULL, since it marks history // Update history entry
// the user removed.
Triple( Triple(
chapterId, chapterId,
Date(max(readAt, dbHistory.read_at?.time ?: 0L)), listOfNotNull(readAt, dbHistory.read_at).maxOrNull(),
max(readDuration, dbHistory.read_duration) - dbHistory.read_duration, max(readDuration, dbHistory.read_duration) - dbHistory.read_duration,
) )
} }
@@ -16,6 +16,7 @@ import tachiyomi.domain.chapter.model.Chapter
import tachiyomi.domain.chapter.model.ChapterRemoteUpdate import tachiyomi.domain.chapter.model.ChapterRemoteUpdate
import tachiyomi.domain.chapter.model.ChapterUpdate import tachiyomi.domain.chapter.model.ChapterUpdate
import tachiyomi.domain.chapter.repository.ChapterRepository import tachiyomi.domain.chapter.repository.ChapterRepository
import kotlin.time.Instant
@Inject @Inject
@SingleIn(AppScope::class) @SingleIn(AppScope::class)
@@ -158,13 +159,13 @@ class ChapterRepositoryImpl(
remoteName: String, remoteName: String,
remoteScanlator: String?, remoteScanlator: String?,
remoteChapterNumber: Double, remoteChapterNumber: Double,
remoteDateUpload: Long, remoteDateUpload: Instant?,
remoteOrder: Long, remoteOrder: Long,
remoteMemo: JsonObject, remoteMemo: JsonObject,
userRead: Boolean, userRead: Boolean,
userBookmark: Boolean, userBookmark: Boolean,
userLastPageRead: Long, userLastPageRead: Long,
stateDateFetch: Long, stateDateFetch: Instant,
): Chapter = Chapter( ): Chapter = Chapter(
id = id, id = id,
mangaId = mangaId, mangaId = mangaId,
@@ -3,13 +3,13 @@ package tachiyomi.data.history
import tachiyomi.domain.history.model.History import tachiyomi.domain.history.model.History
import tachiyomi.domain.history.model.HistoryWithRelations import tachiyomi.domain.history.model.HistoryWithRelations
import tachiyomi.domain.manga.model.MangaCover import tachiyomi.domain.manga.model.MangaCover
import java.util.Date import kotlin.time.Instant
object HistoryMapper { object HistoryMapper {
fun mapHistory( fun mapHistory(
id: Long, id: Long,
chapterId: Long, chapterId: Long,
readAt: Date?, readAt: Instant?,
readDuration: Long, readDuration: Long,
): History = History( ): History = History(
id = id, id = id,
@@ -26,9 +26,9 @@ object HistoryMapper {
thumbnailUrl: String?, thumbnailUrl: String?,
sourceId: Long, sourceId: Long,
isFavorite: Boolean, isFavorite: Boolean,
coverLastModified: Long, coverLastModified: Instant?,
chapterNumber: Double, chapterNumber: Double,
readAt: Date?, readAt: Instant?,
readDuration: Long, readDuration: Long,
): HistoryWithRelations = HistoryWithRelations( ): HistoryWithRelations = HistoryWithRelations(
id = historyId, id = historyId,
@@ -5,6 +5,7 @@ import kotlinx.serialization.json.JsonObject
import tachiyomi.domain.library.model.LibraryManga import tachiyomi.domain.library.model.LibraryManga
import tachiyomi.domain.manga.model.Manga import tachiyomi.domain.manga.model.Manga
import tachiyomi.domain.manga.model.MangaWithChapterCount import tachiyomi.domain.manga.model.MangaWithChapterCount
import kotlin.time.Instant
object MangaMapper { object MangaMapper {
fun mapManga( fun mapManga(
@@ -20,21 +21,21 @@ object MangaMapper {
remoteCover: String?, remoteCover: String?,
remoteUpdateStrategy: UpdateStrategy, remoteUpdateStrategy: UpdateStrategy,
remoteMemo: JsonObject, remoteMemo: JsonObject,
userFavoriteAt: Long?, userFavoriteAt: Instant?,
userNotes: String, userNotes: String,
userReaderFlags: Long, userReaderFlags: Long,
userChapterFlags: Long, userChapterFlags: Long,
stateChapterLastUpdate: Long?, stateChapterLastUpdate: Instant?,
stateChapterNextUpdate: Long?, stateChapterNextUpdate: Instant?,
stateChapterFetchInterval: Long, stateChapterFetchInterval: Long,
stateCoverLastModified: Long, stateCoverLastModified: Instant?,
stateInitialized: Boolean, stateInitialized: Boolean,
): Manga = Manga( ): Manga = Manga(
id = id, id = id,
source = sourceId, source = sourceId,
favoriteAt = userFavoriteAt, favoriteAt = userFavoriteAt,
lastUpdate = stateChapterLastUpdate ?: 0, lastUpdate = stateChapterLastUpdate,
nextUpdate = stateChapterNextUpdate ?: 0, nextUpdate = stateChapterNextUpdate,
fetchInterval = stateChapterFetchInterval.toInt(), fetchInterval = stateChapterFetchInterval.toInt(),
viewerFlags = userReaderFlags, viewerFlags = userReaderFlags,
chapterFlags = userChapterFlags, chapterFlags = userChapterFlags,
@@ -66,20 +67,20 @@ object MangaMapper {
remoteCover: String?, remoteCover: String?,
remoteUpdateStrategy: UpdateStrategy, remoteUpdateStrategy: UpdateStrategy,
remoteMemo: JsonObject, remoteMemo: JsonObject,
userFavoriteAt: Long, userFavoriteAt: Instant,
userNotes: String, userNotes: String,
userReaderFlags: Long, userReaderFlags: Long,
userChapterFlags: Long, userChapterFlags: Long,
stateChapterLastUpdate: Long?, stateChapterLastUpdate: Instant?,
stateChapterNextUpdate: Long?, stateChapterNextUpdate: Instant?,
stateChapterFetchInterval: Long, stateChapterFetchInterval: Long,
stateCoverLastModified: Long, stateCoverLastModified: Instant?,
stateInitialized: Boolean, stateInitialized: Boolean,
totalCount: Long, totalCount: Long,
readCount: Double, readCount: Double,
latestUpload: Long, latestUpload: Instant?,
chapterFetchedAt: Long, chapterFetchedAt: Instant?,
lastRead: Long, lastRead: Instant?,
bookmarkCount: Double, bookmarkCount: Double,
categories: String, categories: String,
): LibraryManga = LibraryManga( ): LibraryManga = LibraryManga(
@@ -128,14 +129,14 @@ object MangaMapper {
remoteCover: String?, remoteCover: String?,
remoteUpdateStrategy: UpdateStrategy, remoteUpdateStrategy: UpdateStrategy,
remoteMemo: JsonObject, remoteMemo: JsonObject,
userFavoriteAt: Long?, userFavoriteAt: Instant?,
userNotes: String, userNotes: String,
userReaderFlags: Long, userReaderFlags: Long,
userChapterFlags: Long, userChapterFlags: Long,
stateChapterLastUpdate: Long?, stateChapterLastUpdate: Instant?,
stateChapterNextUpdate: Long?, stateChapterNextUpdate: Instant?,
stateChapterFetchInterval: Long, stateChapterFetchInterval: Long,
stateCoverLastModified: Long, stateCoverLastModified: Instant?,
stateInitialized: Boolean, stateInitialized: Boolean,
chapterCount: Long, chapterCount: Long,
): MangaWithChapterCount = MangaWithChapterCount( ): MangaWithChapterCount = MangaWithChapterCount(
@@ -100,11 +100,10 @@ class MangaRepositoryImpl(
includedCategories: List<Long>, includedCategories: List<Long>,
): Flow<List<Manga>> { ): Flow<List<Manga>> {
val timeZone = TimeZone.currentSystemDefault() val timeZone = TimeZone.currentSystemDefault()
val epochMillis = val startOfDay = Clock.System.now().toLocalDateTime(timeZone).date.atStartOfDayIn(timeZone)
Clock.System.now().toLocalDateTime(timeZone).date.atStartOfDayIn(timeZone).toEpochMilliseconds()
return database.mangaQueries return database.mangaQueries
.getUpcomingManga( .getUpcomingManga(
startOfDay = epochMillis, startOfDay = startOfDay,
statuses = statuses, statuses = statuses,
includedEmpty = includedCategories.isEmpty(), includedEmpty = includedCategories.isEmpty(),
includedCategories = includedCategories, includedCategories = includedCategories,
@@ -1,6 +1,7 @@
package tachiyomi.data.track package tachiyomi.data.track
import tachiyomi.domain.track.model.Track import tachiyomi.domain.track.model.Track
import kotlin.time.Instant
object TrackMapper { object TrackMapper {
fun mapTrack( fun mapTrack(
@@ -15,8 +16,8 @@ object TrackMapper {
totalChapters: Long, totalChapters: Long,
status: Long, status: Long,
score: Double, score: Double,
startDate: Long, startDate: Instant?,
finishDate: Long, finishDate: Instant?,
private: Boolean, private: Boolean,
): Track = Track( ): Track = Track(
id = id, id = id,
@@ -13,6 +13,7 @@ import tachiyomi.data.subscribeToList
import tachiyomi.domain.manga.model.MangaCover import tachiyomi.domain.manga.model.MangaCover
import tachiyomi.domain.updates.model.UpdatesWithRelations import tachiyomi.domain.updates.model.UpdatesWithRelations
import tachiyomi.domain.updates.repository.UpdatesRepository import tachiyomi.domain.updates.repository.UpdatesRepository
import kotlin.time.Instant
@Inject @Inject
@SingleIn(AppScope::class) @SingleIn(AppScope::class)
@@ -23,14 +24,14 @@ class UpdatesRepositoryImpl(
override suspend fun awaitWithRead( override suspend fun awaitWithRead(
read: Boolean, read: Boolean,
after: Long, after: Instant,
limit: Long, limit: Long,
): List<UpdatesWithRelations> { ): List<UpdatesWithRelations> {
return getUpdatesByReadStatus(read = read, after = after, limit = limit).awaitAsList() return getUpdatesByReadStatus(read = read, after = after, limit = limit).awaitAsList()
} }
override fun subscribeAll( override fun subscribeAll(
after: Long, after: Instant,
limit: Long, limit: Long,
unread: Boolean?, unread: Boolean?,
started: Boolean?, started: Boolean?,
@@ -58,13 +59,13 @@ class UpdatesRepositoryImpl(
override fun subscribeWithRead( override fun subscribeWithRead(
read: Boolean, read: Boolean,
after: Long, after: Instant,
limit: Long, limit: Long,
): Flow<List<UpdatesWithRelations>> { ): Flow<List<UpdatesWithRelations>> {
return getUpdatesByReadStatus(read = read, after = after, limit = limit).subscribeToList() return getUpdatesByReadStatus(read = read, after = after, limit = limit).subscribeToList()
} }
private fun getUpdatesByReadStatus(read: Boolean, after: Long, limit: Long): Query<UpdatesWithRelations> { private fun getUpdatesByReadStatus(read: Boolean, after: Instant, limit: Long): Query<UpdatesWithRelations> {
return if (read) { return if (read) {
database.updatesViewQueries.getReadUpdates( database.updatesViewQueries.getReadUpdates(
after = after, after = after,
@@ -94,9 +95,9 @@ class UpdatesRepositoryImpl(
sourceId: Long, sourceId: Long,
favorite: Boolean, favorite: Boolean,
thumbnailUrl: String?, thumbnailUrl: String?,
coverLastModified: Long, coverLastModified: Instant?,
dateUpload: Long, dateUpload: Instant?,
dateFetch: Long, dateFetch: Instant,
excludedScanlator: String?, excludedScanlator: String?,
): UpdatesWithRelations = UpdatesWithRelations( ): UpdatesWithRelations = UpdatesWithRelations(
mangaId = mangaId, mangaId = mangaId,
@@ -1,4 +1,5 @@
import kotlin.Boolean; import kotlin.Boolean;
import kotlin.time.Instant;
import kotlinx.serialization.json.JsonObject; import kotlinx.serialization.json.JsonObject;
CREATE TABLE chapter( CREATE TABLE chapter(
@@ -8,13 +9,13 @@ CREATE TABLE chapter(
remote_name TEXT NOT NULL, remote_name TEXT NOT NULL,
remote_scanlator TEXT, remote_scanlator TEXT,
remote_chapter_number REAL NOT NULL, remote_chapter_number REAL NOT NULL,
remote_date_upload INTEGER NOT NULL, remote_date_upload INTEGER AS Instant,
remote_order INTEGER NOT NULL, remote_order INTEGER NOT NULL,
remote_memo BLOB AS JsonObject NOT NULL, remote_memo BLOB AS JsonObject NOT NULL,
user_read INTEGER AS Boolean NOT NULL, user_read INTEGER AS Boolean NOT NULL,
user_bookmark INTEGER AS Boolean NOT NULL, user_bookmark INTEGER AS Boolean NOT NULL,
user_last_page_read INTEGER NOT NULL, user_last_page_read INTEGER NOT NULL,
state_date_fetch INTEGER NOT NULL, state_date_fetch INTEGER AS Instant NOT NULL,
UNIQUE(manga_id, remote_url), UNIQUE(manga_id, remote_url),
FOREIGN KEY(manga_id) REFERENCES manga (id) FOREIGN KEY(manga_id) REFERENCES manga (id)
ON DELETE CASCADE ON DELETE CASCADE
@@ -1,10 +1,10 @@
import java.util.Date; import kotlin.time.Instant;
CREATE TABLE history( CREATE TABLE history(
id INTEGER NOT NULL PRIMARY KEY, id INTEGER NOT NULL PRIMARY KEY,
manga_id INTEGER NOT NULL, manga_id INTEGER NOT NULL,
chapter_id INTEGER NOT NULL UNIQUE, chapter_id INTEGER NOT NULL UNIQUE,
read_at INTEGER AS Date, read_at INTEGER AS Instant,
read_duration INTEGER NOT NULL, read_duration INTEGER NOT NULL,
FOREIGN KEY(manga_id) REFERENCES manga (id) FOREIGN KEY(manga_id) REFERENCES manga (id)
ON DELETE CASCADE, ON DELETE CASCADE,
@@ -22,12 +22,12 @@ WHERE manga_id = :mangaId;
resetHistoryById: resetHistoryById:
UPDATE history UPDATE history
SET read_at = 0 SET read_at = NULL
WHERE id = :id; WHERE id = :id;
resetHistoryByMangaId: resetHistoryByMangaId:
UPDATE history UPDATE history
SET read_at = 0 SET read_at = NULL
WHERE manga_id = :mangaId; WHERE manga_id = :mangaId;
removeAllHistory: removeAllHistory:
@@ -35,7 +35,7 @@ DELETE FROM history;
removeResettedHistory: removeResettedHistory:
DELETE FROM history DELETE FROM history
WHERE read_at = 0; WHERE read_at IS NULL;
upsert: upsert:
INSERT INTO history(manga_id, chapter_id, read_at, read_duration) INSERT INTO history(manga_id, chapter_id, read_at, read_duration)
@@ -2,6 +2,7 @@ import eu.kanade.tachiyomi.source.model.UpdateStrategy;
import kotlin.Boolean; import kotlin.Boolean;
import kotlin.String; import kotlin.String;
import kotlin.collections.List; import kotlin.collections.List;
import kotlin.time.Instant;
import kotlinx.serialization.json.JsonObject; import kotlinx.serialization.json.JsonObject;
CREATE TABLE manga( CREATE TABLE manga(
@@ -17,14 +18,14 @@ CREATE TABLE manga(
remote_cover TEXT, remote_cover TEXT,
remote_update_strategy INTEGER AS UpdateStrategy NOT NULL, remote_update_strategy INTEGER AS UpdateStrategy NOT NULL,
remote_memo BLOB AS JsonObject NOT NULL, remote_memo BLOB AS JsonObject NOT NULL,
user_favorite_at INTEGER, user_favorite_at INTEGER AS Instant,
user_notes TEXT NOT NULL, user_notes TEXT NOT NULL,
user_reader_flags INTEGER NOT NULL, user_reader_flags INTEGER NOT NULL,
user_chapter_flags INTEGER NOT NULL, user_chapter_flags INTEGER NOT NULL,
state_chapter_last_update INTEGER, state_chapter_last_update INTEGER AS Instant,
state_chapter_next_update INTEGER, state_chapter_next_update INTEGER AS Instant,
state_chapter_fetch_interval INTEGER NOT NULL, state_chapter_fetch_interval INTEGER NOT NULL,
state_cover_last_modified INTEGER NOT NULL, state_cover_last_modified INTEGER AS Instant,
state_initialized INTEGER AS Boolean NOT NULL, state_initialized INTEGER AS Boolean NOT NULL,
UNIQUE(source_id, remote_url) UNIQUE(source_id, remote_url)
); );
@@ -1,4 +1,5 @@
import kotlin.Boolean; import kotlin.Boolean;
import kotlin.time.Instant;
CREATE TABLE manga_track( CREATE TABLE manga_track(
id INTEGER NOT NULL PRIMARY KEY, id INTEGER NOT NULL PRIMARY KEY,
@@ -12,8 +13,8 @@ CREATE TABLE manga_track(
total_chapters INTEGER NOT NULL, total_chapters INTEGER NOT NULL,
status INTEGER NOT NULL, status INTEGER NOT NULL,
score REAL NOT NULL, score REAL NOT NULL,
start_date INTEGER NOT NULL, start_date INTEGER AS Instant,
finish_date INTEGER NOT NULL, finish_date INTEGER AS Instant,
private INTEGER AS Boolean NOT NULL DEFAULT 0, private INTEGER AS Boolean NOT NULL DEFAULT 0,
UNIQUE (manga_id, tracker_id), UNIQUE (manga_id, tracker_id),
FOREIGN KEY(manga_id) REFERENCES manga (id) FOREIGN KEY(manga_id) REFERENCES manga (id)
@@ -0,0 +1,271 @@
import eu.kanade.tachiyomi.source.model.UpdateStrategy;
import kotlin.Boolean;
import kotlin.String;
import kotlin.collections.List;
import kotlin.time.Instant;
import kotlinx.serialization.json.JsonObject;
-- A time that isn't known was stored as 0, which reads as the start of 1970 once it is an instant, so
-- it is NULL instead. SQLite cannot drop NOT NULL from a column, so the tables holding one are rebuilt.
-- Every view reads `manga` or `chapter`, so they are dropped here and recreated against the new tables below
DROP VIEW historyView;
DROP VIEW libraryView;
DROP VIEW updatesView;
-- Each table is renamed aside and rebuilt under its own name, as in migration 17. Renaming a table also
-- repoints the foreign keys of the tables that reference it, which would leave them on the copy that is
-- dropped; the legacy behavior leaves them naming the table that takes its place.
PRAGMA legacy_alter_table = 1;
-- ---------------------------------------------------------------------------------------------------------
-- table - manga
-- ---------------------------------------------------------------------------------------------------------
ALTER TABLE manga RENAME TO manga_temp;
CREATE TABLE manga(
id INTEGER NOT NULL PRIMARY KEY,
source_id INTEGER NOT NULL,
remote_url TEXT NOT NULL,
remote_title TEXT NOT NULL,
remote_author TEXT,
remote_artist TEXT,
remote_description TEXT,
remote_genre TEXT AS List<String>,
remote_status INTEGER NOT NULL,
remote_cover TEXT,
remote_update_strategy INTEGER AS UpdateStrategy NOT NULL,
remote_memo BLOB AS JsonObject NOT NULL,
user_favorite_at INTEGER AS Instant,
user_notes TEXT NOT NULL,
user_reader_flags INTEGER NOT NULL,
user_chapter_flags INTEGER NOT NULL,
state_chapter_last_update INTEGER AS Instant,
state_chapter_next_update INTEGER AS Instant,
state_chapter_fetch_interval INTEGER NOT NULL,
state_cover_last_modified INTEGER AS Instant,
state_initialized INTEGER AS Boolean NOT NULL,
UNIQUE(source_id, remote_url)
);
-- `user_favorite_at` keeps its 0: NULL already means the entry isn't in the library, and 0 is an entry
-- added before the time was recorded
INSERT INTO manga(
id, source_id, remote_url, remote_title, remote_author, remote_artist, remote_description, remote_genre,
remote_status, remote_cover, remote_update_strategy, remote_memo, user_favorite_at, user_notes,
user_reader_flags, user_chapter_flags, state_chapter_last_update, state_chapter_next_update,
state_chapter_fetch_interval, state_cover_last_modified, state_initialized
)
SELECT
id, source_id, remote_url, remote_title, remote_author, remote_artist, remote_description, remote_genre,
remote_status, remote_cover, remote_update_strategy, remote_memo, user_favorite_at, user_notes,
user_reader_flags, user_chapter_flags, nullif(state_chapter_last_update, 0), nullif(state_chapter_next_update, 0),
state_chapter_fetch_interval, nullif(state_cover_last_modified, 0), state_initialized
FROM manga_temp;
DROP TABLE manga_temp;
CREATE INDEX manga_user_favorite_at_index ON manga(user_favorite_at) WHERE user_favorite_at IS NOT NULL;
-- ---------------------------------------------------------------------------------------------------------
-- table - chapter
-- ---------------------------------------------------------------------------------------------------------
ALTER TABLE chapter RENAME TO chapter_temp;
CREATE TABLE chapter(
id INTEGER NOT NULL PRIMARY KEY,
manga_id INTEGER NOT NULL,
remote_url TEXT NOT NULL,
remote_name TEXT NOT NULL,
remote_scanlator TEXT,
remote_chapter_number REAL NOT NULL,
remote_date_upload INTEGER AS Instant,
remote_order INTEGER NOT NULL,
remote_memo BLOB AS JsonObject NOT NULL,
user_read INTEGER AS Boolean NOT NULL,
user_bookmark INTEGER AS Boolean NOT NULL,
user_last_page_read INTEGER NOT NULL,
state_date_fetch INTEGER AS Instant NOT NULL,
UNIQUE(manga_id, remote_url),
FOREIGN KEY(manga_id) REFERENCES manga (id)
ON DELETE CASCADE
);
INSERT INTO chapter(
id, manga_id, remote_url, remote_name, remote_scanlator, remote_chapter_number, remote_date_upload,
remote_order, remote_memo, user_read, user_bookmark, user_last_page_read, state_date_fetch
)
SELECT
id, manga_id, remote_url, remote_name, remote_scanlator, remote_chapter_number, nullif(remote_date_upload, 0),
remote_order, remote_memo, user_read, user_bookmark, user_last_page_read, state_date_fetch
FROM chapter_temp;
DROP TABLE chapter_temp;
CREATE INDEX chapter_state_date_fetch_index ON chapter(state_date_fetch);
CREATE INDEX chapter_unread_state_date_fetch_index ON chapter(state_date_fetch) WHERE user_read = 0;
-- ---------------------------------------------------------------------------------------------------------
-- table - manga_track
-- ---------------------------------------------------------------------------------------------------------
ALTER TABLE manga_track RENAME TO manga_track_temp;
CREATE TABLE manga_track(
id INTEGER NOT NULL PRIMARY KEY,
manga_id INTEGER NOT NULL,
tracker_id INTEGER NOT NULL,
remote_id INTEGER NOT NULL,
remote_url TEXT NOT NULL,
library_id INTEGER,
title TEXT NOT NULL,
last_chapter_read REAL NOT NULL,
total_chapters INTEGER NOT NULL,
status INTEGER NOT NULL,
score REAL NOT NULL,
start_date INTEGER AS Instant,
finish_date INTEGER AS Instant,
private INTEGER AS Boolean NOT NULL DEFAULT 0,
UNIQUE (manga_id, tracker_id),
FOREIGN KEY(manga_id) REFERENCES manga (id)
ON DELETE CASCADE
);
INSERT INTO manga_track(
id, manga_id, tracker_id, remote_id, remote_url, library_id, title, last_chapter_read, total_chapters,
status, score, start_date, finish_date, private
)
SELECT
id, manga_id, tracker_id, remote_id, remote_url, library_id, title, last_chapter_read, total_chapters,
status, score, nullif(start_date, 0), nullif(finish_date, 0), private
FROM manga_track_temp;
DROP TABLE manga_track_temp;
CREATE INDEX manga_track_tracker_id_remote_id_index ON manga_track(tracker_id, remote_id);
PRAGMA legacy_alter_table = 0;
-- ---------------------------------------------------------------------------------------------------------
-- table - history
-- ---------------------------------------------------------------------------------------------------------
-- 0 marked history the user removed, which NULL marks now
UPDATE history
SET read_at = NULL
WHERE read_at = 0;
-- ---------------------------------------------------------------------------------------------------------
-- views
-- ---------------------------------------------------------------------------------------------------------
CREATE VIEW historyView AS
SELECT
history.id AS id,
manga.id AS mangaId,
chapter.id AS chapterId,
manga.remote_title AS title,
manga.remote_cover AS thumbnailUrl,
manga.source_id AS sourceId,
manga.user_favorite_at IS NOT NULL AS favorite,
manga.state_cover_last_modified AS coverLastModified,
chapter.remote_chapter_number AS chapterNumber,
history.read_at AS readAt,
history.read_duration AS readDuration,
max_read.read_at AS maxReadAt,
max_read.chapter_id AS maxReadAtChapterId
FROM manga
JOIN chapter
ON manga.id = chapter.manga_id
JOIN history
ON chapter.id = history.chapter_id
JOIN (
SELECT manga_id, chapter_id, MAX(read_at) AS read_at
FROM history
GROUP BY manga_id
) AS max_read
ON chapter.manga_id = max_read.manga_id;
-- An entry without chapters or reading history has no latest upload, fetch or read time, which is NULL
-- rather than 0 now
CREATE VIEW libraryView AS
SELECT
M.*,
coalesce(C.total, 0) AS totalCount,
coalesce(C.readCount, 0) AS readCount,
C.latestUpload AS latestUpload,
C.fetchedAt AS chapterFetchedAt,
-- Joining history to every chapter is the slowest part of the query, and only entries with excluded
-- scanlators need the chapters to leave theirs out
CASE WHEN EXISTS (SELECT 0 FROM excluded_scanlator WHERE excluded_scanlator.manga_id = M.id)
THEN (
SELECT max(history.read_at)
FROM history
JOIN chapter
ON chapter.id = history.chapter_id
WHERE history.manga_id = M.id
AND NOT EXISTS (
SELECT 0 FROM excluded_scanlator
WHERE excluded_scanlator.manga_id = M.id
AND excluded_scanlator.scanlator = chapter.remote_scanlator
)
)
ELSE (SELECT max(history.read_at) FROM history WHERE history.manga_id = M.id)
END AS lastRead,
coalesce(C.bookmarkCount, 0) AS bookmarkCount,
coalesce(MC.categories, '0') AS categories
FROM manga M
LEFT JOIN (
SELECT
chapter.manga_id,
count(*) AS total,
sum(user_read) AS readCount,
max(chapter.remote_date_upload) AS latestUpload,
max(chapter.state_date_fetch) AS fetchedAt,
sum(chapter.user_bookmark) AS bookmarkCount
FROM chapter
LEFT JOIN excluded_scanlator
ON chapter.manga_id = excluded_scanlator.manga_id
AND chapter.remote_scanlator = excluded_scanlator.scanlator
WHERE excluded_scanlator.scanlator IS NULL
AND chapter.manga_id IN (SELECT id FROM manga WHERE user_favorite_at IS NOT NULL)
GROUP BY chapter.manga_id
) AS C
ON M.id = C.manga_id
LEFT JOIN (
SELECT manga_id, group_concat(category_id) AS categories
FROM manga_category
WHERE manga_id IN (SELECT id FROM manga WHERE user_favorite_at IS NOT NULL)
GROUP BY manga_id
) AS MC
ON MC.manga_id = M.id
WHERE M.user_favorite_at IS NOT NULL;
CREATE VIEW updatesView AS
SELECT
manga.id AS mangaId,
manga.remote_title AS mangaTitle,
chapter.id AS chapterId,
chapter.remote_name AS chapterName,
chapter.remote_scanlator AS scanlator,
chapter.remote_url AS chapterUrl,
chapter.user_read AS read,
chapter.user_bookmark AS bookmark,
chapter.user_last_page_read AS lastPageRead,
manga.source_id AS sourceId,
manga.user_favorite_at IS NOT NULL AS favorite,
manga.remote_cover AS thumbnailUrl,
manga.state_cover_last_modified AS coverLastModified,
chapter.remote_date_upload AS dateUpload,
chapter.state_date_fetch AS dateFetch,
excluded_scanlator.scanlator AS excludedScanlator
FROM manga JOIN chapter
ON manga.id = chapter.manga_id
LEFT JOIN excluded_scanlator
ON manga.id = excluded_scanlator.manga_id
AND chapter.remote_scanlator = excluded_scanlator.scanlator
WHERE user_favorite_at IS NOT NULL
AND state_date_fetch > user_favorite_at
ORDER BY state_date_fetch DESC;
@@ -39,7 +39,7 @@ chapterNumber,
readAt, readAt,
readDuration readDuration
FROM historyView FROM historyView
WHERE historyView.readAt > 0 WHERE historyView.readAt IS NOT NULL
AND maxReadAtChapterId = historyView.chapterId AND maxReadAtChapterId = historyView.chapterId
AND lower(historyView.title) LIKE ('%' || :query || '%') AND lower(historyView.title) LIKE ('%' || :query || '%')
ORDER BY readAt DESC; ORDER BY readAt DESC;
@@ -62,6 +62,6 @@ JOIN manga
ON manga.id = history.manga_id ON manga.id = history.manga_id
JOIN chapter JOIN chapter
ON chapter.id = history.chapter_id ON chapter.id = history.chapter_id
WHERE history.read_at > 0 WHERE history.read_at IS NOT NULL
ORDER BY history.read_at DESC ORDER BY history.read_at DESC
LIMIT 1; LIMIT 1;
@@ -3,28 +3,25 @@ SELECT
M.*, M.*,
coalesce(C.total, 0) AS totalCount, coalesce(C.total, 0) AS totalCount,
coalesce(C.readCount, 0) AS readCount, coalesce(C.readCount, 0) AS readCount,
coalesce(C.latestUpload, 0) AS latestUpload, C.latestUpload AS latestUpload,
coalesce(C.fetchedAt, 0) AS chapterFetchedAt, C.fetchedAt AS chapterFetchedAt,
-- Joining history to every chapter is the slowest part of the query, and only entries with excluded -- Joining history to every chapter is the slowest part of the query, and only entries with excluded
-- scanlators need the chapters to leave theirs out -- scanlators need the chapters to leave theirs out
coalesce( CASE WHEN EXISTS (SELECT 0 FROM excluded_scanlator WHERE excluded_scanlator.manga_id = M.id)
CASE WHEN EXISTS (SELECT 0 FROM excluded_scanlator WHERE excluded_scanlator.manga_id = M.id) THEN (
THEN ( SELECT max(history.read_at)
SELECT max(history.read_at) FROM history
FROM history JOIN chapter
JOIN chapter ON chapter.id = history.chapter_id
ON chapter.id = history.chapter_id WHERE history.manga_id = M.id
WHERE history.manga_id = M.id AND NOT EXISTS (
AND NOT EXISTS ( SELECT 0 FROM excluded_scanlator
SELECT 0 FROM excluded_scanlator WHERE excluded_scanlator.manga_id = M.id
WHERE excluded_scanlator.manga_id = M.id AND excluded_scanlator.scanlator = chapter.remote_scanlator
AND excluded_scanlator.scanlator = chapter.remote_scanlator
)
) )
ELSE (SELECT max(history.read_at) FROM history WHERE history.manga_id = M.id) )
END, ELSE (SELECT max(history.read_at) FROM history WHERE history.manga_id = M.id)
0 END AS lastRead,
) AS lastRead,
coalesce(C.bookmarkCount, 0) AS bookmarkCount, coalesce(C.bookmarkCount, 0) AS bookmarkCount,
coalesce(MC.categories, '0') AS categories coalesce(MC.categories, '0') AS categories
FROM manga M FROM manga M
@@ -33,8 +30,8 @@ LEFT JOIN (
chapter.manga_id, chapter.manga_id,
count(*) AS total, count(*) AS total,
sum(user_read) AS readCount, sum(user_read) AS readCount,
coalesce(max(chapter.remote_date_upload), 0) AS latestUpload, max(chapter.remote_date_upload) AS latestUpload,
coalesce(max(chapter.state_date_fetch), 0) AS fetchedAt, max(chapter.state_date_fetch) AS fetchedAt,
sum(chapter.user_bookmark) AS bookmarkCount sum(chapter.user_bookmark) AS bookmarkCount
FROM chapter FROM chapter
LEFT JOIN excluded_scanlator LEFT JOIN excluded_scanlator
@@ -3,7 +3,7 @@ package tachiyomi.domain.backup.model
import tachiyomi.domain.chapter.model.Chapter import tachiyomi.domain.chapter.model.Chapter
import tachiyomi.domain.manga.model.Manga import tachiyomi.domain.manga.model.Manga
import tachiyomi.domain.track.model.Track import tachiyomi.domain.track.model.Track
import java.util.Date import kotlin.time.Instant
data class RestoredManga( data class RestoredManga(
val manga: Manga, val manga: Manga,
@@ -16,6 +16,6 @@ data class RestoredManga(
data class RestoredHistory( data class RestoredHistory(
val chapterUrl: String, val chapterUrl: String,
val readAt: Date?, val readAt: Instant?,
val readDuration: Long, val readDuration: Long,
) )
@@ -2,6 +2,7 @@ package tachiyomi.domain.chapter.model
import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonObject
import mihon.core.common.extensions.EMPTY import mihon.core.common.extensions.EMPTY
import kotlin.time.Instant
data class Chapter( data class Chapter(
val id: Long, val id: Long,
@@ -9,11 +10,11 @@ data class Chapter(
val read: Boolean, val read: Boolean,
val bookmark: Boolean, val bookmark: Boolean,
val lastPageRead: Long, val lastPageRead: Long,
val dateFetch: Long, val dateFetch: Instant,
val sourceOrder: Long, val sourceOrder: Long,
val url: String, val url: String,
val name: String, val name: String,
val dateUpload: Long, val dateUpload: Instant?,
val chapterNumber: Double, val chapterNumber: Double,
val scanlator: String?, val scanlator: String?,
val memo: JsonObject, val memo: JsonObject,
@@ -38,11 +39,11 @@ data class Chapter(
read = false, read = false,
bookmark = false, bookmark = false,
lastPageRead = 0, lastPageRead = 0,
dateFetch = 0, dateFetch = Instant.fromEpochMilliseconds(0),
sourceOrder = 0, sourceOrder = 0,
url = "", url = "",
name = "", name = "",
dateUpload = -1, dateUpload = null,
chapterNumber = -1.0, chapterNumber = -1.0,
scanlator = null, scanlator = null,
memo = JsonObject.EMPTY, memo = JsonObject.EMPTY,
@@ -1,13 +1,14 @@
package tachiyomi.domain.chapter.model package tachiyomi.domain.chapter.model
import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonObject
import kotlin.time.Instant
data class ChapterRemoteUpdate( data class ChapterRemoteUpdate(
val id: Long, val id: Long,
val name: String, val name: String,
val scanlator: String?, val scanlator: String?,
val chapterNumber: Double, val chapterNumber: Double,
val dateUpload: Long?, val dateUpload: Instant?,
val sourceOrder: Long, val sourceOrder: Long,
val memo: JsonObject, val memo: JsonObject,
) )
@@ -1,12 +1,13 @@
package tachiyomi.domain.chapter.model package tachiyomi.domain.chapter.model
import mihon.domain.common.PartialUpdate import mihon.domain.common.PartialUpdate
import kotlin.time.Instant
class ChapterUpdate(val id: Long, block: ChapterUpdate.() -> Unit) : PartialUpdate() { class ChapterUpdate(val id: Long, block: ChapterUpdate.() -> Unit) : PartialUpdate() {
var read: Boolean? by field(null) var read: Boolean? by field(null)
var bookmark: Boolean? by field(null) var bookmark: Boolean? by field(null)
var lastPageRead: Long? by field(null) var lastPageRead: Long? by field(null)
var dateFetch: Long? by field(null) var dateFetch: Instant? by field(null)
init { init {
block() block()
@@ -21,8 +21,8 @@ fun getChapterSort(
false -> { c1, c2 -> c1.chapterNumber.compareTo(c2.chapterNumber) } false -> { c1, c2 -> c1.chapterNumber.compareTo(c2.chapterNumber) }
} }
Manga.CHAPTER_SORTING_UPLOAD_DATE -> when (sortDescending) { Manga.CHAPTER_SORTING_UPLOAD_DATE -> when (sortDescending) {
true -> { c1, c2 -> c2.dateUpload.compareTo(c1.dateUpload) } true -> { c1, c2 -> compareValues(c2.dateUpload, c1.dateUpload) }
false -> { c1, c2 -> c1.dateUpload.compareTo(c2.dateUpload) } false -> { c1, c2 -> compareValues(c1.dateUpload, c2.dateUpload) }
} }
Manga.CHAPTER_SORTING_ALPHABET -> when (sortDescending) { Manga.CHAPTER_SORTING_ALPHABET -> when (sortDescending) {
true -> { c1, c2 -> c2.name.compareToWithCollator(c1.name) } true -> { c1, c2 -> c2.name.compareToWithCollator(c1.name) }
@@ -1,11 +1,11 @@
package tachiyomi.domain.history.model package tachiyomi.domain.history.model
import java.util.Date import kotlin.time.Instant
data class History( data class History(
val id: Long, val id: Long,
val chapterId: Long, val chapterId: Long,
val readAt: Date?, val readAt: Instant?,
val readDuration: Long, val readDuration: Long,
) { ) {
companion object { companion object {
@@ -1,9 +1,9 @@
package tachiyomi.domain.history.model package tachiyomi.domain.history.model
import java.util.Date import kotlin.time.Instant
data class HistoryUpdate( data class HistoryUpdate(
val chapterId: Long, val chapterId: Long,
val readAt: Date, val readAt: Instant,
val sessionReadDuration: Long, val sessionReadDuration: Long,
) )
@@ -1,7 +1,7 @@
package tachiyomi.domain.history.model package tachiyomi.domain.history.model
import tachiyomi.domain.manga.model.MangaCover import tachiyomi.domain.manga.model.MangaCover
import java.util.Date import kotlin.time.Instant
data class HistoryWithRelations( data class HistoryWithRelations(
val id: Long, val id: Long,
@@ -9,7 +9,7 @@ data class HistoryWithRelations(
val mangaId: Long, val mangaId: Long,
val title: String, val title: String,
val chapterNumber: Double, val chapterNumber: Double,
val readAt: Date?, val readAt: Instant?,
val readDuration: Long, val readDuration: Long,
val coverData: MangaCover, val coverData: MangaCover,
) )
@@ -1,6 +1,7 @@
package tachiyomi.domain.library.model package tachiyomi.domain.library.model
import tachiyomi.domain.manga.model.Manga import tachiyomi.domain.manga.model.Manga
import kotlin.time.Instant
data class LibraryManga( data class LibraryManga(
val manga: Manga, val manga: Manga,
@@ -8,9 +9,9 @@ data class LibraryManga(
val totalChapters: Long, val totalChapters: Long,
val readCount: Long, val readCount: Long,
val bookmarkCount: Long, val bookmarkCount: Long,
val latestUpload: Long, val latestUpload: Instant?,
val chapterFetchedAt: Long, val chapterFetchedAt: Instant?,
val lastRead: Long, val lastRead: Instant?,
) { ) {
val id: Long = manga.id val id: Long = manga.id
@@ -15,6 +15,7 @@ import tachiyomi.domain.manga.model.MangaUpdate
import kotlin.math.absoluteValue import kotlin.math.absoluteValue
import kotlin.time.Clock import kotlin.time.Clock
import kotlin.time.Duration.Companion.days import kotlin.time.Duration.Companion.days
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Instant import kotlin.time.Instant
@Inject @Inject
@@ -26,17 +27,13 @@ class FetchInterval(
manga: Manga, manga: Manga,
dateTime: LocalDateTime, dateTime: LocalDateTime,
timeZone: TimeZone, timeZone: TimeZone,
window: Pair<Long, Long>, window: ClosedRange<Instant>?,
): MangaUpdate { ): MangaUpdate {
val interval = manga.fetchInterval.takeIf { it < 0 } ?: calculateInterval( val interval = manga.fetchInterval.takeIf { it < 0 } ?: calculateInterval(
chapters = getChaptersByMangaId.await(manga.id, applyScanlatorFilter = true), chapters = getChaptersByMangaId.await(manga.id, applyScanlatorFilter = true),
zone = timeZone, zone = timeZone,
) )
val currentWindow = if (window.first == 0L && window.second == 0L) { val currentWindow = window ?: getWindow(Clock.System.now().toLocalDateTime(timeZone).date, timeZone)
getWindow(Clock.System.now().toLocalDateTime(timeZone).date, timeZone)
} else {
window
}
val nextUpdate = calculateNextUpdate(manga, interval, dateTime, timeZone, currentWindow) val nextUpdate = calculateNextUpdate(manga, interval, dateTime, timeZone, currentWindow)
return MangaUpdate(manga.id) { return MangaUpdate(manga.id) {
@@ -45,22 +42,19 @@ class FetchInterval(
} }
} }
fun getWindow(localDateTime: LocalDate, timeZone: TimeZone): Pair<Long, Long> { fun getWindow(localDateTime: LocalDate, timeZone: TimeZone): ClosedRange<Instant> {
val today = localDateTime.atStartOfDayIn(timeZone) val today = localDateTime.atStartOfDayIn(timeZone)
val lowerBound = today - GRACE_PERIOD.days return (today - GRACE_PERIOD.days)..(today + GRACE_PERIOD.days)
val upperBound = today + GRACE_PERIOD.days
return Pair(lowerBound.toEpochMilliseconds(), upperBound.toEpochMilliseconds())
} }
internal fun calculateInterval(chapters: List<Chapter>, zone: TimeZone): Int { internal fun calculateInterval(chapters: List<Chapter>, zone: TimeZone): Int {
val chapterWindow = if (chapters.size <= 8) 3 else 10 val chapterWindow = if (chapters.size <= 8) 3 else 10
val uploadDates = chapters.asSequence() val uploadDates = chapters.asSequence()
.filter { it.dateUpload > 0L } .mapNotNull { it.dateUpload }
.sortedByDescending { it.dateUpload } .sortedDescending()
.map { .map {
Instant.fromEpochMilliseconds(it.dateUpload) it.toLocalDateTime(zone)
.toLocalDateTime(zone)
.date .date
.atStartOfDayIn(zone) .atStartOfDayIn(zone)
} }
@@ -69,10 +63,10 @@ class FetchInterval(
.toList() .toList()
val fetchDates = chapters.asSequence() val fetchDates = chapters.asSequence()
.sortedByDescending { it.dateFetch } .map { it.dateFetch }
.sortedDescending()
.map { .map {
Instant.fromEpochMilliseconds(it.dateFetch) it.toLocalDateTime(zone)
.toLocalDateTime(zone)
.date .date
.atStartOfDayIn(zone) .atStartOfDayIn(zone)
} }
@@ -103,13 +97,13 @@ class FetchInterval(
interval: Int, interval: Int,
dateTime: LocalDateTime, dateTime: LocalDateTime,
timeZone: TimeZone, timeZone: TimeZone,
window: Pair<Long, Long>, window: ClosedRange<Instant>,
): Long { ): Instant {
if (manga.nextUpdate in window.first.rangeTo(window.second + 1)) { if (manga.nextUpdate != null && manga.nextUpdate in window.start..window.endInclusive + 1.milliseconds) {
return manga.nextUpdate return manga.nextUpdate
} }
val instant = if (manga.lastUpdate > 0) Instant.fromEpochMilliseconds(manga.lastUpdate) else Clock.System.now() val instant = manga.lastUpdate ?: Clock.System.now()
val latestDate = instant.toLocalDateTime(timeZone).date.atStartOfDayIn(timeZone) val latestDate = instant.toLocalDateTime(timeZone).date.atStartOfDayIn(timeZone)
val daysSinceLatest = (dateTime.toInstant(timeZone) - latestDate).inWholeDays val daysSinceLatest = (dateTime.toInstant(timeZone) - latestDate).inWholeDays
@@ -119,7 +113,7 @@ class FetchInterval(
) )
val offsetDays = ((cycle + 1) * interval.absoluteValue.toLong()).days val offsetDays = ((cycle + 1) * interval.absoluteValue.toLong()).days
return latestDate.plus(offsetDays).toEpochMilliseconds() return latestDate.plus(offsetDays)
} }
private fun increaseInterval(delta: Int, daysSinceLatest: Long, increaseWhenOver: Int): Int { private fun increaseInterval(delta: Int, daysSinceLatest: Long, increaseWhenOver: Int): Int {
@@ -19,13 +19,13 @@ import java.io.Serializable as JavaSerializable
data class Manga( data class Manga(
val id: Long, val id: Long,
val source: Long, val source: Long,
val lastUpdate: Long, val lastUpdate: Instant?,
val nextUpdate: Long, val nextUpdate: Instant?,
val fetchInterval: Int, val fetchInterval: Int,
val favoriteAt: Long?, val favoriteAt: Instant?,
val viewerFlags: Long, val viewerFlags: Long,
val chapterFlags: Long, val chapterFlags: Long,
val coverLastModified: Long, val coverLastModified: Instant?,
val url: String, val url: String,
val title: String, val title: String,
val artist: String?, val artist: String?,
@@ -44,9 +44,7 @@ data class Manga(
get() = favoriteAt != null get() = favoriteAt != null
val expectedNextUpdate: Instant? val expectedNextUpdate: Instant?
get() = nextUpdate get() = nextUpdate?.takeIf { status != SManga.COMPLETED.toLong() }
.takeIf { status != SManga.COMPLETED.toLong() }
?.let { Instant.fromEpochMilliseconds(it) }
val sorting: Long val sorting: Long
get() = chapterFlags and CHAPTER_SORTING_MASK get() = chapterFlags and CHAPTER_SORTING_MASK
@@ -111,18 +109,23 @@ data class Manga(
const val CHAPTER_DISPLAY_NUMBER = 0x00100000L const val CHAPTER_DISPLAY_NUMBER = 0x00100000L
const val CHAPTER_DISPLAY_MASK = 0x00100000L const val CHAPTER_DISPLAY_MASK = 0x00100000L
/**
* [favoriteAt] of an entry added to the library before the time it was added was recorded.
*/
val UNKNOWN_FAVORITE_AT = Instant.fromEpochMilliseconds(0)
fun create() = Manga( fun create() = Manga(
id = -1L, id = -1L,
url = "", url = "",
title = "", title = "",
source = -1L, source = -1L,
lastUpdate = 0L, lastUpdate = null,
nextUpdate = 0L, nextUpdate = null,
fetchInterval = 0, fetchInterval = 0,
favoriteAt = null, favoriteAt = null,
viewerFlags = 0L, viewerFlags = 0L,
chapterFlags = 0L, chapterFlags = 0L,
coverLastModified = 0L, coverLastModified = null,
artist = null, artist = null,
author = null, author = null,
description = null, description = null,
@@ -1,5 +1,7 @@
package tachiyomi.domain.manga.model package tachiyomi.domain.manga.model
import kotlin.time.Instant
/** /**
* Contains the required data for MangaCoverFetcher * Contains the required data for MangaCoverFetcher
*/ */
@@ -8,7 +10,7 @@ data class MangaCover(
val sourceId: Long, val sourceId: Long,
val isMangaFavorite: Boolean, val isMangaFavorite: Boolean,
val url: String?, val url: String?,
val lastModified: Long, val lastModified: Instant?,
) )
fun Manga.asMangaCover(): MangaCover { fun Manga.asMangaCover(): MangaCover {
@@ -2,6 +2,7 @@ package tachiyomi.domain.manga.model
import eu.kanade.tachiyomi.source.model.UpdateStrategy import eu.kanade.tachiyomi.source.model.UpdateStrategy
import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonObject
import kotlin.time.Instant
data class MangaRemoteUpdate( data class MangaRemoteUpdate(
val id: Long, val id: Long,
@@ -15,5 +16,5 @@ data class MangaRemoteUpdate(
val updateStrategy: UpdateStrategy, val updateStrategy: UpdateStrategy,
val memo: JsonObject, val memo: JsonObject,
val initialized: Boolean, val initialized: Boolean,
val coverLastModified: Long?, val coverLastModified: Instant?,
) )
@@ -1,15 +1,16 @@
package tachiyomi.domain.manga.model package tachiyomi.domain.manga.model
import mihon.domain.common.PartialUpdate import mihon.domain.common.PartialUpdate
import kotlin.time.Instant
class MangaUpdate(val id: Long, block: MangaUpdate.() -> Unit) : PartialUpdate() { class MangaUpdate(val id: Long, block: MangaUpdate.() -> Unit) : PartialUpdate() {
var favoriteAt: Long? by field(null) var favoriteAt: Instant? by field(null)
var lastUpdate: Long? by field(null) var lastUpdate: Instant? by field(null)
var nextUpdate: Long? by field(null) var nextUpdate: Instant? by field(null)
var fetchInterval: Int? by field(null) var fetchInterval: Int? by field(null)
var viewerFlags: Long? by field(null) var viewerFlags: Long? by field(null)
var chapterFlags: Long? by field(null) var chapterFlags: Long? by field(null)
var coverLastModified: Long? by field(null) var coverLastModified: Instant? by field(null)
var notes: String? by field(null) var notes: String? by field(null)
init { init {
@@ -1,6 +1,7 @@
package tachiyomi.domain.track.model package tachiyomi.domain.track.model
import java.io.Serializable import java.io.Serializable
import kotlin.time.Instant
data class Track( data class Track(
val id: Long, val id: Long,
@@ -14,7 +15,7 @@ data class Track(
val status: Long, val status: Long,
val score: Double, val score: Double,
val remoteUrl: String, val remoteUrl: String,
val startDate: Long, val startDate: Instant?,
val finishDate: Long, val finishDate: Instant?,
val private: Boolean, val private: Boolean,
) : Serializable ) : Serializable
@@ -11,7 +11,7 @@ class GetUpdates(
private val repository: UpdatesRepository, private val repository: UpdatesRepository,
) { ) {
suspend fun await(read: Boolean, after: Long): List<UpdatesWithRelations> { suspend fun await(read: Boolean, after: Instant): List<UpdatesWithRelations> {
return repository.awaitWithRead(read, after, limit = 500) return repository.awaitWithRead(read, after, limit = 500)
} }
@@ -25,7 +25,7 @@ class GetUpdates(
excludedCategories: List<Long>, excludedCategories: List<Long>,
): Flow<List<UpdatesWithRelations>> { ): Flow<List<UpdatesWithRelations>> {
return repository.subscribeAll( return repository.subscribeAll(
instant.toEpochMilliseconds(), instant,
limit = 500, limit = 500,
unread = unread, unread = unread,
started = started, started = started,
@@ -36,7 +36,7 @@ class GetUpdates(
) )
} }
fun subscribe(read: Boolean, after: Long): Flow<List<UpdatesWithRelations>> { fun subscribe(read: Boolean, after: Instant): Flow<List<UpdatesWithRelations>> {
return repository.subscribeWithRead(read, after, limit = 500) return repository.subscribeWithRead(read, after, limit = 500)
} }
} }
@@ -1,6 +1,7 @@
package tachiyomi.domain.updates.model package tachiyomi.domain.updates.model
import tachiyomi.domain.manga.model.MangaCover import tachiyomi.domain.manga.model.MangaCover
import kotlin.time.Instant
data class UpdatesWithRelations( data class UpdatesWithRelations(
val mangaId: Long, val mangaId: Long,
@@ -13,6 +14,6 @@ data class UpdatesWithRelations(
val bookmark: Boolean, val bookmark: Boolean,
val lastPageRead: Long, val lastPageRead: Long,
val sourceId: Long, val sourceId: Long,
val dateFetch: Long, val dateFetch: Instant,
val coverData: MangaCover, val coverData: MangaCover,
) )
@@ -2,13 +2,14 @@ package tachiyomi.domain.updates.repository
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import tachiyomi.domain.updates.model.UpdatesWithRelations import tachiyomi.domain.updates.model.UpdatesWithRelations
import kotlin.time.Instant
interface UpdatesRepository { interface UpdatesRepository {
suspend fun awaitWithRead(read: Boolean, after: Long, limit: Long): List<UpdatesWithRelations> suspend fun awaitWithRead(read: Boolean, after: Instant, limit: Long): List<UpdatesWithRelations>
fun subscribeAll( fun subscribeAll(
after: Long, after: Instant,
limit: Long, limit: Long,
unread: Boolean?, unread: Boolean?,
started: Boolean?, started: Boolean?,
@@ -18,5 +19,5 @@ interface UpdatesRepository {
excludedCategories: List<Long>, excludedCategories: List<Long>,
): Flow<List<UpdatesWithRelations>> ): Flow<List<UpdatesWithRelations>>
fun subscribeWithRead(read: Boolean, after: Long, limit: Long): Flow<List<UpdatesWithRelations>> fun subscribeWithRead(read: Boolean, after: Instant, limit: Long): Flow<List<UpdatesWithRelations>>
} }
@@ -12,8 +12,7 @@ import tachiyomi.domain.chapter.model.Chapter
import kotlin.time.Duration import kotlin.time.Duration
import kotlin.time.Duration.Companion.days import kotlin.time.Duration.Companion.days
import kotlin.time.Duration.Companion.hours import kotlin.time.Duration.Companion.hours
import kotlin.time.DurationUnit import kotlin.time.Instant
import kotlin.time.toDuration
@Execution(ExecutionMode.CONCURRENT) @Execution(ExecutionMode.CONCURRENT)
class FetchIntervalTest { class FetchIntervalTest {
@@ -21,8 +20,8 @@ class FetchIntervalTest {
private val testTime = LocalDateTime.parse("2020-01-01T00:00:00") private val testTime = LocalDateTime.parse("2020-01-01T00:00:00")
private val testTimeZone = TimeZone.UTC private val testTimeZone = TimeZone.UTC
private var chapter = Chapter.create().copy( private var chapter = Chapter.create().copy(
dateFetch = testTime.toInstant(testTimeZone).toEpochMilliseconds(), dateFetch = testTime.toInstant(testTimeZone),
dateUpload = testTime.toInstant(testTimeZone).toEpochMilliseconds(), dateUpload = testTime.toInstant(testTimeZone),
) )
private val fetchInterval = FetchInterval(mockk()) private val fetchInterval = FetchInterval(mockk())
@@ -35,7 +34,7 @@ class FetchIntervalTest {
fetchInterval.calculateInterval(chaptersWithUploadDate, testTimeZone) shouldBe 7 fetchInterval.calculateInterval(chaptersWithUploadDate, testTimeZone) shouldBe 7
val chaptersWithoutUploadDate = chaptersWithUploadDate.map { val chaptersWithoutUploadDate = chaptersWithUploadDate.map {
it.copy(dateUpload = 0L) it.copy(dateUpload = null)
} }
fetchInterval.calculateInterval(chaptersWithoutUploadDate, testTimeZone) shouldBe 7 fetchInterval.calculateInterval(chaptersWithoutUploadDate, testTimeZone) shouldBe 7
} }
@@ -119,7 +118,7 @@ class FetchIntervalTest {
fetchInterval.calculateInterval(chaptersWithUploadDate, testTimeZone) shouldBe 1 fetchInterval.calculateInterval(chaptersWithUploadDate, testTimeZone) shouldBe 1
val chaptersWithoutUploadDate = chaptersWithUploadDate.map { val chaptersWithoutUploadDate = chaptersWithUploadDate.map {
it.copy(dateUpload = 0L) it.copy(dateUpload = null)
} }
fetchInterval.calculateInterval(chaptersWithoutUploadDate, testTimeZone) shouldBe 1 fetchInterval.calculateInterval(chaptersWithoutUploadDate, testTimeZone) shouldBe 1
} }
@@ -133,10 +132,10 @@ class FetchIntervalTest {
} }
private fun chapterWithTime(chapter: Chapter, duration: Duration): Chapter { private fun chapterWithTime(chapter: Chapter, duration: Duration): Chapter {
val newTime = testTime.toInstant(testTimeZone).plus(duration).toEpochMilliseconds() val newTime = testTime.toInstant(testTimeZone) + duration
return chapter.copy(dateFetch = newTime, dateUpload = newTime) return chapter.copy(dateFetch = newTime, dateUpload = newTime)
} }
private fun List<Chapter>.lastUploadDate() = private fun List<Chapter>.lastUploadDate() =
last().dateUpload.toDuration(DurationUnit.MILLISECONDS) last().dateUpload!! - Instant.fromEpochMilliseconds(0)
} }
@@ -96,7 +96,7 @@ abstract class BaseUpdatesGridGlanceWidget : GlanceAppWidget() {
val flow = remember { val flow = remember {
getUpdates getUpdates
.subscribe(false, DateLimit.toEpochMilliseconds()) .subscribe(false, DateLimit)
.map { rawData -> .map { rawData ->
rawData.prepareData(context, rowCount, columnCount) rawData.prepareData(context, rowCount, columnCount)
} }
@@ -24,7 +24,7 @@ class WidgetManager(
context(context: Context) context(context: Context)
fun init(scope: LifecycleCoroutineScope) { fun init(scope: LifecycleCoroutineScope) {
combine( combine(
getUpdates.subscribe(read = false, after = BaseUpdatesGridGlanceWidget.DateLimit.toEpochMilliseconds()), getUpdates.subscribe(read = false, after = BaseUpdatesGridGlanceWidget.DateLimit),
securityPreferences.useAuthenticator.changes(), securityPreferences.useAuthenticator.changes(),
transform = { a, b -> a to b }, transform = { a, b -> a to b },
) )