StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
feat: Add M3U classification migration and repository implementation
David Nashashbf52ae626d04
diff --git a/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt b/app/src/main/java/com/streamvault/app/di/DatabaseModule.ktindex 30b9e7a2..ec6c4129 100644--- a/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt+++ b/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt@@ -95,5 +95,6 @@ object DatabaseModule {@Provides fun provideProviderConfigRevisionDao(db: StreamVaultDatabase): ProviderConfigRevisionDao = db.providerConfigRevisionDao()@Provides fun provideBackupRestoreCheckpointDao(db: StreamVaultDatabase): BackupRestoreCheckpointDao = db.backupRestoreCheckpointDao()@Provides fun provideProviderWorkflowDao(db: StreamVaultDatabase): ProviderWorkflowDao = db.providerWorkflowDao()+ @Provides fun provideM3uClassificationDao(db: StreamVaultDatabase): M3uClassificationDao = db.m3uClassificationDao()@Provides fun providePluginProviderOwnershipDao(db: StreamVaultDatabase): PluginProviderOwnershipDao = db.pluginProviderOwnershipDao()}diff --git a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt b/app/src/main/java/com/streamvault/app/di/RepositoryModule.ktindex ff566fd5..06b9204c 100644--- a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt+++ b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt@@ -83,6 +83,9 @@ abstract class RepositoryModule {@Binds @Singletonabstract fun bindPlaybackHistoryRepository(impl: PlaybackHistoryRepositoryImpl): PlaybackHistoryRepository+ @Binds @Singleton+ abstract fun bindM3uClassificationRepository(impl: M3uClassificationRepositoryImpl): M3uClassificationRepository+@Binds @Singletonabstract fun bindExternalRatingsRepository(impl: ExternalRatingsRepositoryImpl): ExternalRatingsRepositorydiff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/AddToGroupDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/AddToGroupDialog.ktindex 01195cb4..4fdca945 100644--- a/app/src/main/java/com/streamvault/app/ui/components/dialogs/AddToGroupDialog.kt+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/AddToGroupDialog.kt@@ -49,7 +49,10 @@ fun AddToGroupDialog(isQueuedForSplitScreen: Boolean = false,onOpenSplitScreenPlanner: (() -> Unit)? = null,onRemoveFromRecent: (() -> Unit)? = null,- onHideChannel: (() -> Unit)? = null+ onHideChannel: (() -> Unit)? = null,+ onMoveToMovies: (() -> Unit)? = null,+ onMoveToSeries: (() -> Unit)? = null,+ onMoveBackToLive: (() -> Unit)? = null) {var showCreateGroup by remember { mutableStateOf(false) }val isTelevisionDevice = rememberIsTelevisionDevice()@@ -80,6 +83,9 @@ fun AddToGroupDialog(val safeOpenSplitScreenPlanner = { if (canInteract) onOpenSplitScreenPlanner?.invoke() }val safeRemoveFromRecent = { if (canInteract) onRemoveFromRecent?.invoke() }val safeHideChannel = { if (canInteract) onHideChannel?.invoke() }+ val safeMoveToMovies = { if (canInteract) onMoveToMovies?.invoke() }+ val safeMoveToSeries = { if (canInteract) onMoveToSeries?.invoke() }+ val safeMoveBackToLive = { if (canInteract) onMoveBackToLive?.invoke() }val safeCreateGroup = { if (canInteract && onCreateGroup != null) showCreateGroup = true }val safeAddToGroup: (Category) -> Unit = { group -> if (canInteract) onAddToGroup(group) }val safeRemoveFromGroup: (Category) -> Unit = { group -> if (canInteract) onRemoveFromGroup(group) }@@ -181,6 +187,45 @@ fun AddToGroupDialog(}}+ if (onMoveToMovies != null) {+ item {+ Button(+ onClick = safeMoveToMovies,+ modifier = Modifier.fillMaxWidth().mouseClickable(onClick = safeMoveToMovies),+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Brand,+ contentColor = Color.Black+ )+ ) { Text(stringResource(R.string.m3u_move_to_movies)) }+ }+ }++ if (onMoveToSeries != null) {+ item {+ Button(+ onClick = safeMoveToSeries,+ modifier = Modifier.fillMaxWidth().mouseClickable(onClick = safeMoveToSeries),+ colors = ButtonDefaults.colors(+ containerColor = AppColors.Success,+ contentColor = Color.Black+ )+ ) { Text(stringResource(R.string.m3u_move_to_series)) }+ }+ }++ if (onMoveBackToLive != null) {+ item {+ Button(+ onClick = safeMoveBackToLive,+ modifier = Modifier.fillMaxWidth().mouseClickable(onClick = safeMoveBackToLive),+ colors = ButtonDefaults.colors(+ containerColor = MaterialTheme.colorScheme.errorContainer,+ contentColor = MaterialTheme.colorScheme.onErrorContainer+ )+ ) { Text(stringResource(R.string.m3u_move_back_to_live)) }+ }+ }+// ── Split Screen ─────────────────────────────if (channel != null && onOpenSplitScreenPlanner != null) {item {diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.ktindex 80a0dcb9..10919a50 100644--- a/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.kt+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/CategoryOptionsDialog.kt@@ -50,7 +50,8 @@ fun CategoryOptionsDialog(onClearAll: (() -> Unit)? = null,onToggleLock: (() -> Unit)? = null,onDelete: (() -> Unit)? = null,- onReorderChannels: (() -> Unit)? = null+ onReorderChannels: (() -> Unit)? = null,+ onOrganizeM3u: (() -> Unit)? = null) {var canInteract by remember { mutableStateOf(false) }val blockOpenGesture = rememberDialogOpenGestureBlocker(canInteract)@@ -175,6 +176,13 @@ fun CategoryOptionsDialog()}+ if (onOrganizeM3u != null) {+ PremiumDialogAction(+ label = stringResource(R.string.m3u_organize_items),+ onClick = { if (canInteract) onOrganizeM3u() }+ )+ }+if (onToggleLock != null) {PremiumDialogAction(label = if (category.isUserProtected) {diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uCategoryOrganizerDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uCategoryOrganizerDialog.ktnew file mode 100644index 00000000..b9fdd963--- /dev/null+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uCategoryOrganizerDialog.kt@@ -0,0 +1,83 @@+package com.streamvault.app.ui.components.dialogs++import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.padding+import androidx.compose.runtime.Composable+import androidx.compose.ui.Modifier+import androidx.compose.ui.graphics.Color+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.unit.dp+import androidx.compose.ui.window.Dialog+import androidx.compose.ui.window.DialogProperties+import androidx.tv.material3.Button+import androidx.tv.material3.ButtonDefaults+import androidx.tv.material3.MaterialTheme+import androidx.tv.material3.Surface+import androidx.tv.material3.SurfaceDefaults+import androidx.tv.material3.Text+import com.streamvault.app.R+import com.streamvault.app.ui.theme.OnSurface+import com.streamvault.app.ui.theme.SurfaceElevated+import com.streamvault.domain.repository.M3uClassificationTarget++@Composable+fun M3uCategoryOrganizerDialog(+ categoryName: String,+ onDismiss: () -> Unit,+ onTargetSelected: (M3uClassificationTarget) -> Unit+) {+ Dialog(+ onDismissRequest = onDismiss,+ properties = DialogProperties(usePlatformDefaultWidth = false)+ ) {+ Surface(+ modifier = Modifier.fillMaxWidth(0.55f),+ colors = SurfaceDefaults.colors(containerColor = SurfaceElevated)+ ) {+ Column(+ modifier = Modifier.padding(28.dp),+ verticalArrangement = Arrangement.spacedBy(12.dp)+ ) {+ Text(categoryName, style = MaterialTheme.typography.headlineSmall, color = OnSurface)+ Text(+ stringResource(R.string.m3u_category_rule_subtitle),+ color = OnSurface.copy(alpha = 0.75f)+ )+ Button(+ onClick = { onTargetSelected(M3uClassificationTarget.MOVIE) },+ modifier = Modifier.fillMaxWidth(),+ colors = ButtonDefaults.colors(+ containerColor = MaterialTheme.colorScheme.primary,+ contentColor = Color.Black+ )+ ) { Text(stringResource(R.string.m3u_move_to_movies)) }+ Button(+ onClick = { onTargetSelected(M3uClassificationTarget.SERIES) },+ modifier = Modifier.fillMaxWidth(),+ colors = ButtonDefaults.colors(+ containerColor = MaterialTheme.colorScheme.secondary,+ contentColor = Color.Black+ )+ ) { Text(stringResource(R.string.m3u_move_to_series)) }+ Button(+ onClick = { onTargetSelected(M3uClassificationTarget.LIVE) },+ modifier = Modifier.fillMaxWidth(),+ colors = ButtonDefaults.colors(+ containerColor = Color.White.copy(alpha = 0.08f),+ contentColor = OnSurface+ )+ ) { Text(stringResource(R.string.m3u_keep_live)) }+ Button(+ onClick = onDismiss,+ modifier = Modifier.fillMaxWidth(),+ colors = ButtonDefaults.colors(+ containerColor = Color.White.copy(alpha = 0.08f),+ contentColor = OnSurface+ )+ ) { Text(stringResource(R.string.category_options_cancel)) }+ }+ }+ }+}diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uCategorySeriesAssignmentDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uCategorySeriesAssignmentDialog.ktnew file mode 100644index 00000000..86e5be19--- /dev/null+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uCategorySeriesAssignmentDialog.kt@@ -0,0 +1,191 @@+package com.streamvault.app.ui.components.dialogs++import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.Row+import androidx.compose.foundation.layout.fillMaxHeight+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.padding+import androidx.compose.foundation.lazy.LazyColumn+import androidx.compose.foundation.lazy.items+import androidx.compose.material3.OutlinedTextField+import androidx.compose.material3.OutlinedTextFieldDefaults+import androidx.compose.runtime.Composable+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue+import androidx.compose.ui.Modifier+import androidx.compose.ui.graphics.Color+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.unit.dp+import androidx.compose.ui.window.Dialog+import androidx.compose.ui.window.DialogProperties+import androidx.tv.material3.Button+import androidx.tv.material3.ButtonDefaults+import androidx.tv.material3.MaterialTheme+import androidx.tv.material3.Surface+import androidx.tv.material3.SurfaceDefaults+import androidx.tv.material3.Text+import com.streamvault.app.R+import com.streamvault.app.ui.theme.OnSurface+import com.streamvault.app.ui.theme.SurfaceElevated+import com.streamvault.domain.repository.M3uCategoryItem+import com.streamvault.domain.repository.M3uSeriesAssignment++@Composable+fun M3uCategorySeriesAssignmentDialog(+ categoryName: String,+ items: List<M3uCategoryItem>,+ onDismiss: () -> Unit,+ onConfirm: (Map<Long, M3uSeriesAssignment>) -> Unit+) {+ var drafts by remember(items) {+ mutableStateOf(+ items.associate { item ->+ item.channelId to M3uAssignmentDraft(+ seriesName = item.suggestedAssignment.seriesName,+ seasonNumber = item.suggestedAssignment.seasonNumber.toString(),+ episodeNumber = (item.suggestedAssignment.episodeNumber ?: 0).toString()+ )+ }+ )+ }++ Dialog(+ onDismissRequest = onDismiss,+ properties = DialogProperties(usePlatformDefaultWidth = false)+ ) {+ Surface(+ modifier = Modifier+ .fillMaxWidth(0.84f)+ .fillMaxHeight(0.86f),+ colors = SurfaceDefaults.colors(containerColor = SurfaceElevated)+ ) {+ Column(+ modifier = Modifier.padding(28.dp),+ verticalArrangement = Arrangement.spacedBy(12.dp)+ ) {+ Text(+ text = stringResource(R.string.m3u_series_review_title, categoryName),+ style = MaterialTheme.typography.headlineSmall,+ color = OnSurface+ )+ Text(+ text = stringResource(R.string.m3u_series_review_subtitle),+ color = OnSurface.copy(alpha = 0.75f)+ )+ LazyColumn(+ modifier = Modifier.weight(1f),+ verticalArrangement = Arrangement.spacedBy(14.dp)+ ) {+ items(items, key = { it.channelId }) { item ->+ val draft = drafts[item.channelId] ?: return@items+ Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {+ Text(item.title, color = OnSurface)+ Row(+ modifier = Modifier.fillMaxWidth(),+ horizontalArrangement = Arrangement.spacedBy(8.dp)+ ) {+ AssignmentField(+ value = draft.seriesName,+ label = stringResource(R.string.m3u_series_name),+ onValueChange = { value ->+ drafts = drafts + (item.channelId to draft.copy(seriesName = value))+ },+ modifier = Modifier.weight(1.8f)+ )+ AssignmentField(+ value = draft.seasonNumber,+ label = stringResource(R.string.m3u_season_number),+ onValueChange = { value ->+ drafts = drafts + (item.channelId to draft.copy(seasonNumber = value.filter(Char::isDigit)))+ },+ modifier = Modifier.weight(0.7f)+ )+ AssignmentField(+ value = draft.episodeNumber,+ label = stringResource(R.string.m3u_episode_number),+ onValueChange = { value ->+ drafts = drafts + (item.channelId to draft.copy(episodeNumber = value.filter(Char::isDigit)))+ },+ modifier = Modifier.weight(0.7f)+ )+ }+ if (draft.episodeNumber.toIntOrNull() == 0) {+ Text(+ text = stringResource(R.string.m3u_episode_unresolved),+ color = MaterialTheme.colorScheme.error+ )+ }+ }+ }+ }+ Row(+ modifier = Modifier.fillMaxWidth(),+ horizontalArrangement = Arrangement.spacedBy(12.dp)+ ) {+ Button(+ onClick = {+ onConfirm(+ items.associate { item ->+ val draft = drafts.getValue(item.channelId)+ item.channelId to M3uSeriesAssignment(+ seriesName = draft.seriesName.trim(),+ seasonNumber = draft.seasonNumber.toIntOrNull()?.coerceAtLeast(1) ?: 1,+ episodeNumber = draft.episodeNumber.toIntOrNull()?.coerceAtLeast(0) ?: 0,+ episodeTitle = item.title+ )+ }+ )+ },+ enabled = items.isNotEmpty() && drafts.values.all { it.seriesName.isNotBlank() },+ modifier = Modifier.weight(1f),+ colors = ButtonDefaults.colors(+ containerColor = MaterialTheme.colorScheme.primary,+ contentColor = Color.Black+ )+ ) { Text(stringResource(R.string.m3u_classify)) }+ Button(+ onClick = onDismiss,+ modifier = Modifier.weight(1f),+ colors = ButtonDefaults.colors(+ containerColor = Color.White.copy(alpha = 0.08f),+ contentColor = OnSurface+ )+ ) { Text(stringResource(R.string.category_options_cancel)) }+ }+ }+ }+ }+}++private data class M3uAssignmentDraft(+ val seriesName: String,+ val seasonNumber: String,+ val episodeNumber: String+)++@Composable+private fun AssignmentField(+ value: String,+ label: String,+ onValueChange: (String) -> Unit,+ modifier: Modifier+) {+ OutlinedTextField(+ value = value,+ onValueChange = onValueChange,+ label = { Text(label) },+ singleLine = true,+ modifier = modifier,+ colors = OutlinedTextFieldDefaults.colors(+ focusedTextColor = OnSurface,+ unfocusedTextColor = OnSurface,+ focusedBorderColor = MaterialTheme.colorScheme.primary,+ unfocusedBorderColor = OnSurface.copy(alpha = 0.4f),+ focusedLabelColor = MaterialTheme.colorScheme.primary,+ unfocusedLabelColor = OnSurface.copy(alpha = 0.7f)+ )+ )+}diff --git a/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uSeriesAssignmentDialog.kt b/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uSeriesAssignmentDialog.ktnew file mode 100644index 00000000..accd9982--- /dev/null+++ b/app/src/main/java/com/streamvault/app/ui/components/dialogs/M3uSeriesAssignmentDialog.kt@@ -0,0 +1,122 @@+package com.streamvault.app.ui.components.dialogs++import androidx.compose.foundation.layout.Arrangement+import androidx.compose.foundation.layout.Column+import androidx.compose.foundation.layout.fillMaxWidth+import androidx.compose.foundation.layout.padding+import androidx.compose.material3.OutlinedTextField+import androidx.compose.material3.OutlinedTextFieldDefaults+import androidx.compose.runtime.Composable+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue+import androidx.compose.ui.Modifier+import androidx.compose.ui.graphics.Color+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.unit.dp+import androidx.compose.ui.window.Dialog+import androidx.compose.ui.window.DialogProperties+import androidx.tv.material3.Button+import androidx.tv.material3.ButtonDefaults+import androidx.tv.material3.MaterialTheme+import androidx.tv.material3.Surface+import androidx.tv.material3.SurfaceDefaults+import androidx.tv.material3.Text+import com.streamvault.app.R+import com.streamvault.app.ui.theme.OnSurface+import com.streamvault.app.ui.theme.SurfaceElevated+import com.streamvault.domain.repository.M3uSeriesAssignment++@Composable+fun M3uSeriesAssignmentDialog(+ initialTitle: String,+ onDismiss: () -> Unit,+ onConfirm: (M3uSeriesAssignment) -> Unit+) {+ var seriesName by remember { mutableStateOf(initialTitle.trim()) }+ var season by remember { mutableStateOf("1") }+ var episode by remember { mutableStateOf("1") }++ Dialog(+ onDismissRequest = onDismiss,+ properties = DialogProperties(usePlatformDefaultWidth = false)+ ) {+ Surface(+ modifier = Modifier.fillMaxWidth(0.55f),+ colors = SurfaceDefaults.colors(containerColor = SurfaceElevated)+ ) {+ Column(+ modifier = Modifier.padding(28.dp),+ verticalArrangement = Arrangement.spacedBy(14.dp)+ ) {+ Text(+ text = stringResource(R.string.m3u_move_to_series),+ style = MaterialTheme.typography.headlineSmall,+ color = OnSurface+ )+ Text(+ text = stringResource(R.string.m3u_series_name),+ color = OnSurface+ )+ M3uTextField(seriesName, { seriesName = it }, stringResource(R.string.m3u_series_name))+ M3uTextField(season, { season = it.filter(Char::isDigit) }, stringResource(R.string.m3u_season_number))+ M3uTextField(episode, { episode = it.filter(Char::isDigit) }, stringResource(R.string.m3u_episode_number))+ Button(+ onClick = {+ if (seriesName.isNotBlank()) {+ onConfirm(+ M3uSeriesAssignment(+ seriesName = seriesName.trim(),+ seasonNumber = season.toIntOrNull()?.coerceAtLeast(1) ?: 1,+ episodeNumber = episode.toIntOrNull()?.coerceAtLeast(1) ?: 1+ )+ )+ }+ },+ enabled = seriesName.isNotBlank(),+ modifier = Modifier.fillMaxWidth(),+ colors = ButtonDefaults.colors(+ containerColor = MaterialTheme.colorScheme.primary,+ contentColor = Color.Black+ )+ ) {+ Text(stringResource(R.string.m3u_classify))+ }+ Button(+ onClick = onDismiss,+ modifier = Modifier.fillMaxWidth(),+ colors = ButtonDefaults.colors(+ containerColor = Color.White.copy(alpha = 0.08f),+ contentColor = OnSurface+ )+ ) {+ Text(stringResource(R.string.category_options_cancel))+ }+ }+ }+ }+}++@Composable+private fun M3uTextField(+ value: String,+ onValueChange: (String) -> Unit,+ label: String+) {+ OutlinedTextField(+ value = value,+ onValueChange = onValueChange,+ label = { Text(label) },+ singleLine = true,+ modifier = Modifier.fillMaxWidth(),+ colors = OutlinedTextFieldDefaults.colors(+ focusedTextColor = OnSurface,+ unfocusedTextColor = OnSurface,+ focusedBorderColor = MaterialTheme.colorScheme.primary,+ unfocusedBorderColor = OnSurface.copy(alpha = 0.4f),+ focusedLabelColor = MaterialTheme.colorScheme.primary,+ unfocusedLabelColor = OnSurface.copy(alpha = 0.7f)+ )+ )+}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreenDialogs.kt b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreenDialogs.ktindex 3ca531f7..fba17374 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreenDialogs.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeScreenDialogs.kt@@ -21,6 +21,9 @@ import com.streamvault.app.ui.components.dialogs.PremiumDialogimport com.streamvault.app.ui.components.dialogs.PremiumDialogActionButtonimport com.streamvault.app.ui.components.dialogs.PremiumDialogFooterButtonimport com.streamvault.app.ui.components.dialogs.RenameGroupDialog+import com.streamvault.app.ui.components.dialogs.M3uCategoryOrganizerDialog+import com.streamvault.app.ui.components.dialogs.M3uCategorySeriesAssignmentDialog+import com.streamvault.app.ui.components.dialogs.M3uSeriesAssignmentDialogimport com.streamvault.app.ui.screens.multiview.MultiViewPlannerDialogimport com.streamvault.app.ui.screens.multiview.MultiViewViewModelimport com.streamvault.domain.model.ActiveLiveSource@@ -30,6 +33,9 @@ import com.streamvault.domain.model.LegacyProvider as Providerimport com.streamvault.domain.model.Resultimport com.streamvault.domain.model.VirtualCategoryIdsimport com.streamvault.domain.repository.ChannelRepository+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.repository.M3uCategoryItem+import com.streamvault.domain.repository.M3uClassificationTargetimport kotlinx.coroutines.CoroutineScopeimport kotlinx.coroutines.delayimport kotlinx.coroutines.launch@@ -61,6 +67,10 @@ internal fun HomeDialogsHost(scope: CoroutineScope) {val context = LocalContext.current+ var pendingM3uSeriesChannel by remember { mutableStateOf<Channel?>(null) }+ var pendingM3uCategory by remember { mutableStateOf<Category?>(null) }+ var pendingM3uSeriesCategory by remember { mutableStateOf<Category?>(null) }+ var pendingM3uSeriesItems by remember { mutableStateOf<List<M3uCategoryItem>?>(null) }if (showPinDialog) {PinDialog(@@ -172,6 +182,18 @@ internal fun HomeDialogsHost(} else null,onReorderChannels = if (!isCategoryLocked && category.isVirtual && category.id != VirtualCategoryIds.RECENT) {{ viewModel.enterChannelReorderMode(category) }+ } else null,+ onOrganizeM3u = if (+ !isCategoryLocked &&+ !uiState.isCombinedLiveSource &&+ uiState.provider?.type == ProviderType.M3U &&+ category.type == com.streamvault.domain.model.ContentType.LIVE &&+ !category.isVirtual+ ) {+ {+ pendingM3uCategory = category+ viewModel.dismissCategoryOptions()+ }} else null)}@@ -257,7 +279,67 @@ internal fun HomeDialogsHost(viewModel.onDismissDialog()}} else null,- onHideChannel = { viewModel.hideChannel(channel) }+ onHideChannel = { viewModel.hideChannel(channel) },+ onMoveToMovies = if (!uiState.isCombinedLiveSource && uiState.provider?.type == ProviderType.M3U) {+ { viewModel.moveM3uChannelToMovies(channel) }+ } else null,+ onMoveToSeries = if (!uiState.isCombinedLiveSource && uiState.provider?.type == ProviderType.M3U) {+ {+ pendingM3uSeriesChannel = channel+ viewModel.onDismissDialog()+ }+ } else null+ )+ }++ pendingM3uSeriesChannel?.let { channel ->+ M3uSeriesAssignmentDialog(+ initialTitle = channel.name,+ onDismiss = { pendingM3uSeriesChannel = null },+ onConfirm = { assignment ->+ pendingM3uSeriesChannel = null+ viewModel.moveM3uChannelToSeries(channel, assignment)+ }+ )+ }++ pendingM3uCategory?.let { category ->+ M3uCategoryOrganizerDialog(+ categoryName = category.name,+ onDismiss = { pendingM3uCategory = null },+ onTargetSelected = { target ->+ if (target == M3uClassificationTarget.SERIES) {+ pendingM3uCategory = null+ viewModel.loadM3uCategoryItems(category) { items ->+ pendingM3uSeriesCategory = category+ pendingM3uSeriesItems = items+ }+ } else {+ pendingM3uCategory = null+ viewModel.organizeM3uCategory(category, target)+ }+ }+ )+ }++ if (pendingM3uSeriesCategory != null && pendingM3uSeriesItems != null) {+ val category = pendingM3uSeriesCategory!!+ M3uCategorySeriesAssignmentDialog(+ categoryName = category.name,+ items = pendingM3uSeriesItems!!,+ onDismiss = {+ pendingM3uSeriesCategory = null+ pendingM3uSeriesItems = null+ },+ onConfirm = { assignments ->+ pendingM3uSeriesCategory = null+ pendingM3uSeriesItems = null+ viewModel.organizeM3uCategory(+ category = category,+ target = M3uClassificationTarget.SERIES,+ seriesAssignments = assignments+ )+ })}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.ktindex ac25acd2..5ec0f2a9 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt@@ -43,6 +43,10 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.LiveStreamProgramRequestimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepository+import com.streamvault.domain.repository.M3uClassificationRepository+import com.streamvault.domain.repository.M3uCategoryItem+import com.streamvault.domain.repository.M3uClassificationTarget+import com.streamvault.domain.repository.M3uSeriesAssignmentimport com.streamvault.domain.util.AdultContentVisibilityPolicyimport com.streamvault.domain.usecase.GetCustomCategoriesimport com.streamvault.domain.usecase.UnlockParentalCategory@@ -77,6 +81,7 @@ class HomeViewModel @Inject constructor(private val preferencesRepository: PreferencesRepository,private val epgRepository: EpgRepository,private val playbackHistoryRepository: PlaybackHistoryRepository,+ private val m3uClassificationRepository: M3uClassificationRepository,private val getCustomCategories: GetCustomCategories,private val unlockParentalCategory: UnlockParentalCategory,private val parentalControlManager: ParentalControlManager,@@ -1603,6 +1608,82 @@ class HomeViewModel @Inject constructor(_uiState.update { it.copy(showDialog = false, selectedChannelForDialog = null) }}+ fun moveM3uChannelToMovies(channel: Channel) {+ if (!isM3uUiContext()) return+ viewModelScope.launch {+ when (val result = m3uClassificationRepository.classifyChannel(+ providerId = channel.providerId,+ channelId = channel.id,+ target = M3uClassificationTarget.MOVIE+ )) {+ is Result.Success -> {+ onDismissDialog()+ _uiState.update { it.copy(userMessage = "Moved '${channel.name}' to Movies") }+ }+ is Result.Error -> _uiState.update { it.copy(userMessage = result.message) }+ Result.Loading -> Unit+ }+ }+ }++ fun moveM3uChannelToSeries(channel: Channel, assignment: M3uSeriesAssignment) {+ if (!isM3uUiContext()) return+ viewModelScope.launch {+ when (val result = m3uClassificationRepository.classifyChannel(+ providerId = channel.providerId,+ channelId = channel.id,+ target = M3uClassificationTarget.SERIES,+ series = assignment+ )) {+ is Result.Success -> {+ onDismissDialog()+ _uiState.update { it.copy(userMessage = "Moved '${channel.name}' to Series") }+ }+ is Result.Error -> _uiState.update { it.copy(userMessage = result.message) }+ Result.Loading -> Unit+ }+ }+ }++ fun loadM3uCategoryItems(category: Category, onLoaded: (List<M3uCategoryItem>) -> Unit) {+ if (!isM3uUiContext()) return+ val providerId = _uiState.value.provider?.id ?: return+ viewModelScope.launch {+ when (val result = m3uClassificationRepository.getCategoryItems(providerId, category.id)) {+ is Result.Success -> onLoaded(result.data)+ is Result.Error -> _uiState.update { it.copy(userMessage = result.message) }+ Result.Loading -> Unit+ }+ }+ }++ fun organizeM3uCategory(+ category: Category,+ target: M3uClassificationTarget,+ seriesAssignments: Map<Long, M3uSeriesAssignment> = emptyMap()+ ) {+ if (!isM3uUiContext()) return+ val providerId = _uiState.value.provider?.id ?: return+ viewModelScope.launch {+ when (val result = m3uClassificationRepository.classifyCategory(+ providerId = providerId,+ categoryId = category.id,+ target = target,+ seriesAssignments = seriesAssignments+ )) {+ is Result.Success -> {+ dismissCategoryOptions()+ _uiState.update { it.copy(userMessage = "M3U category rule saved") }+ }+ is Result.Error -> _uiState.update { it.copy(userMessage = result.message) }+ Result.Loading -> Unit+ }+ }+ }++ private fun isM3uUiContext(): Boolean =+ !_uiState.value.isCombinedLiveSource && _uiState.value.provider?.type == ProviderType.M3U+fun onShowHiddenChannelsDialog() {_uiState.update { it.copy(showHiddenChannelsDialog = true) }}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.ktindex 09957884..4a6c273d 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesScreen.kt@@ -281,7 +281,10 @@ fun MoviesScreen(},onAddToGroup = { group -> viewModel.addToGroup(movie, group) },onRemoveFromGroup = { group -> viewModel.removeFromGroup(movie, group) },- onCreateGroup = { name -> viewModel.createCustomGroup(name) }+ onCreateGroup = { name -> viewModel.createCustomGroup(name) },+ onMoveBackToLive = if (uiState.isM3uProvider) {+ { viewModel.moveM3uMovieBackToLive(movie) }+ } else null)}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.ktindex ba7f2732..0ee0ab63 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/movies/MoviesViewModel.kt@@ -22,6 +22,7 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.MovieRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepository+import com.streamvault.domain.repository.M3uClassificationRepositoryimport com.streamvault.domain.usecase.ContinueWatchingResultimport com.streamvault.domain.usecase.ContinueWatchingScopeimport com.streamvault.domain.usecase.GetContinueWatching@@ -81,7 +82,8 @@ class MoviesViewModel @Inject constructor(private val favoriteRepository: FavoriteRepository,private val getContinueWatching: GetContinueWatching,private val getCustomCategories: GetCustomCategories,- private val parentalControlManager: ParentalControlManager+ private val parentalControlManager: ParentalControlManager,+ private val m3uClassificationRepository: M3uClassificationRepository) : ViewModel() {private companion object {const val UNCATEGORIZED = "Uncategorized"@@ -132,6 +134,7 @@ class MoviesViewModel @Inject constructor(_uiState.update {it.copy(hasActiveProvider = provider != null,+ isM3uProvider = provider?.type == ProviderType.M3U,isLoading = if (provider == null) false else it.isLoading,isLoadingSelectedCategory = if (provider == null) false else it.isLoadingSelectedCategory,isLoadingPreviewRows = if (provider == null) false else it.isLoadingPreviewRows@@ -739,6 +742,21 @@ class MoviesViewModel @Inject constructor(_uiState.update { it.copy(showDialog = false, selectedMovieForDialog = null) }}+ fun moveM3uMovieBackToLive(movie: Movie) {+ viewModelScope.launch {+ val provider = providerRepository.getActiveProvider().first() ?: return@launch+ if (provider.type != ProviderType.M3U) return@launch+ when (val result = m3uClassificationRepository.moveMovieBackToLive(provider.id, movie.id)) {+ is Result.Success -> {+ onDismissDialog()+ _uiState.update { it.copy(userMessage = "Moved '${movie.name}' back to Live TV") }+ }+ is Result.Error -> _uiState.update { it.copy(userMessage = result.message) }+ Result.Loading -> Unit+ }+ }+ }+fun addFavorite(movie: Movie) {viewModelScope.launch {setVodFavorite(movie.providerId, movie.selectedRawMovieId(), ContentType.MOVIE, true, favoriteRepository)@@ -1402,6 +1420,7 @@ data class MoviesUiState(val continueWatching: List<PlaybackHistory> = emptyList(),val hasProviders: Boolean = false,val hasActiveProvider: Boolean = false,+ val isM3uProvider: Boolean = false,val isLoading: Boolean = true,val isLoadingPreviewRows: Boolean = false,val hasMorePreviewRows: Boolean = false,diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.ktindex 0cabbde4..6c6076b5 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesScreen.kt@@ -281,7 +281,10 @@ fun SeriesScreen(},onAddToGroup = { group -> viewModel.addToGroup(series, group) },onRemoveFromGroup = { group -> viewModel.removeFromGroup(series, group) },- onCreateGroup = { name -> viewModel.createCustomGroup(name) }+ onCreateGroup = { name -> viewModel.createCustomGroup(name) },+ onMoveBackToLive = if (uiState.isM3uProvider) {+ { viewModel.moveM3uSeriesBackToLive(series) }+ } else null)}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.ktindex 2f3d7f0d..b1b5c4e2 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/series/SeriesViewModel.kt@@ -22,6 +22,7 @@ import com.streamvault.domain.repository.FavoriteRepositoryimport com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport com.streamvault.domain.repository.SeriesRepository+import com.streamvault.domain.repository.M3uClassificationRepositoryimport com.streamvault.domain.usecase.ContinueWatchingResultimport com.streamvault.domain.usecase.ContinueWatchingScopeimport com.streamvault.domain.usecase.GetContinueWatching@@ -81,7 +82,8 @@ class SeriesViewModel @Inject constructor(private val favoriteRepository: FavoriteRepository,private val getContinueWatching: GetContinueWatching,private val getCustomCategories: GetCustomCategories,- private val parentalControlManager: ParentalControlManager+ private val parentalControlManager: ParentalControlManager,+ private val m3uClassificationRepository: M3uClassificationRepository) : ViewModel() {private companion object {const val UNCATEGORIZED = "Uncategorized"@@ -132,6 +134,7 @@ class SeriesViewModel @Inject constructor(_uiState.update {it.copy(hasActiveProvider = provider != null,+ isM3uProvider = provider?.type == ProviderType.M3U,isLoading = if (provider == null) false else it.isLoading,isLoadingSelectedCategory = if (provider == null) false else it.isLoadingSelectedCategory,isLoadingPreviewRows = if (provider == null) false else it.isLoadingPreviewRows@@ -732,6 +735,21 @@ class SeriesViewModel @Inject constructor(_uiState.update { it.copy(showDialog = false, selectedSeriesForDialog = null) }}+ fun moveM3uSeriesBackToLive(series: Series) {+ viewModelScope.launch {+ val provider = providerRepository.getActiveProvider().first() ?: return@launch+ if (provider.type != ProviderType.M3U) return@launch+ when (val result = m3uClassificationRepository.moveSeriesBackToLive(provider.id, series.id)) {+ is Result.Success -> {+ onDismissDialog()+ _uiState.update { it.copy(userMessage = "Moved '${series.name}' back to Live TV") }+ }+ is Result.Error -> _uiState.update { it.copy(userMessage = result.message) }+ Result.Loading -> Unit+ }+ }+ }+fun addFavorite(series: Series) {viewModelScope.launch {setVodFavorite(series.providerId, series.selectedRawSeriesId(), ContentType.SERIES, true, favoriteRepository)@@ -1404,6 +1422,7 @@ data class SeriesUiState(val continueWatching: List<PlaybackHistory> = emptyList(),val hasProviders: Boolean = false,val hasActiveProvider: Boolean = false,+ val isM3uProvider: Boolean = false,val isLoading: Boolean = true,val isLoadingPreviewRows: Boolean = false,val hasMorePreviewRows: Boolean = false,diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xmlindex 3272aa88..5f96a0ba 100644--- a/app/src/main/res/values/strings.xml+++ b/app/src/main/res/values/strings.xml@@ -164,6 +164,20 @@<string name="category_options_clear_recent">Clear All Recent</string><string name="category_options_pin">Pin Category</string><string name="category_options_unpin">Unpin Category</string>+ <string name="m3u_organize_items">Organize M3U Items</string>+ <string name="m3u_move_to_movies">Move to Movies</string>+ <string name="m3u_move_to_series">Move to Series</string>+ <string name="m3u_move_back_to_live">Move back to Live TV</string>+ <string name="m3u_series_name">Series name</string>+ <string name="m3u_episode_number">Episode number</string>+ <string name="m3u_season_number">Season number</string>+ <string name="m3u_classify">Classify</string>+ <string name="m3u_classification_saved">M3U classification saved</string>+ <string name="m3u_category_rule_subtitle">Choose a default for this M3U group. Individual channels can still be overridden.</string>+ <string name="m3u_keep_live">Keep as Live TV</string>+ <string name="m3u_series_review_title">Organize series in %1$s</string>+ <string name="m3u_series_review_subtitle">Review the automatic suggestions or assign each entry to a series, season, and episode.</string>+ <string name="m3u_episode_unresolved">Episode number unresolved — it will remain flagged for correction.</string><string name="category_pinned">Pinned %1$s.</string><string name="category_unpinned">Unpinned %1$s.</string>diff --git a/data/schemas/com.streamvault.data.local.StreamVaultDatabase/76.json b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/76.jsonnew file mode 100644index 00000000..3cd401cd--- /dev/null+++ b/data/schemas/com.streamvault.data.local.StreamVaultDatabase/76.json@@ -0,0 +1,6818 @@+{+ "formatVersion": 1,+ "database": {+ "version": 76,+ "identityHash": "f07479b71082d5112b7a7ea89a69720d",+ "entities": [+ {+ "tableName": "providers",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `type` TEXT NOT NULL, `is_active` INTEGER NOT NULL, `status` TEXT NOT NULL, `last_synced_at` INTEGER NOT NULL, `created_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "isActive",+ "columnName": "is_active",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncedAt",+ "columnName": "last_synced_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_providers_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_type` ON `${TABLE_NAME}` (`type`)"+ },+ {+ "name": "index_providers_is_active",+ "unique": false,+ "columnNames": [+ "is_active"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_providers_is_active` ON `${TABLE_NAME}` (`is_active`)"+ }+ ]+ },+ {+ "tableName": "provider_configs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `type` TEXT NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `identity_key` TEXT NOT NULL, `encrypted_config_json` TEXT NOT NULL, `guide_source_policy` TEXT NOT NULL, `channel_logo_source_policy` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "identityKey",+ "columnName": "identity_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "encryptedConfigJson",+ "columnName": "encrypted_config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "guideSourcePolicy",+ "columnName": "guide_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelLogoSourcePolicy",+ "columnName": "channel_logo_source_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_configs_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_configs_identity_key",+ "unique": true,+ "columnNames": [+ "identity_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_configs_identity_key` ON `${TABLE_NAME}` (`identity_key`)"+ },+ {+ "name": "index_provider_configs_type",+ "unique": false,+ "columnNames": [+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_configs_type` ON `${TABLE_NAME}` (`type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_account_runtime",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `max_connections` INTEGER NOT NULL, `expiration_date` INTEGER, `api_version` TEXT, `allowed_output_formats_json` TEXT NOT NULL, `catalog_layout` TEXT NOT NULL, `catalog_layout_detection_version` INTEGER NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "maxConnections",+ "columnName": "max_connections",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "expirationDate",+ "columnName": "expiration_date",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "apiVersion",+ "columnName": "api_version",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "allowedOutputFormatsJson",+ "columnName": "allowed_output_formats_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayout",+ "columnName": "catalog_layout",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "catalogLayoutDetectionVersion",+ "columnName": "catalog_layout_detection_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_account_runtime_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_account_runtime_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `quality_options_json` TEXT, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "qualityOptionsJson",+ "columnName": "quality_options_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channels_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_channels_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channels_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_channels_logical_group_id",+ "unique": false,+ "columnNames": [+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_logical_group_id` ON `${TABLE_NAME}` (`logical_group_id`)"+ },+ {+ "name": "index_channels_provider_id_category_id_logical_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "logical_group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channels_provider_id_category_id_logical_group_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `logical_group_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_preferences",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `channel_id` INTEGER NOT NULL, `aspect_ratio` TEXT, `audio_video_offset_ms` INTEGER, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`channel_id`) REFERENCES `channels`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "aspectRatio",+ "columnName": "aspect_ratio",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "audioVideoOffsetMs",+ "columnName": "audio_video_offset_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_preferences_channel_id",+ "unique": true,+ "columnNames": [+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_preferences_channel_id` ON `${TABLE_NAME}` (`channel_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "channels",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "channel_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channels_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`channels`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "channels",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_UPDATE BEFORE UPDATE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_BEFORE_DELETE BEFORE DELETE ON `channels` BEGIN DELETE FROM `channels_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_UPDATE AFTER UPDATE ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_channels_fts_AFTER_INSERT AFTER INSERT ON `channels` BEGIN INSERT INTO `channels_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "movies",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `added_at` INTEGER NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_movies_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movies_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_movies_provider_id_stream_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "stream_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_movies_provider_id_stream_id` ON `${TABLE_NAME}` (`provider_id`, `stream_id`)"+ },+ {+ "name": "index_movies_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_movies_provider_id_added_at_release_date_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "added_at",+ "release_date",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movies_provider_id_added_at_release_date_name_id` ON `${TABLE_NAME}` (`provider_id`, `added_at`, `release_date`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movies_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`movies`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "movies",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_UPDATE BEFORE UPDATE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_BEFORE_DELETE BEFORE DELETE ON `movies` BEGIN DELETE FROM `movies_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_UPDATE AFTER UPDATE ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_movies_fts_AFTER_INSERT AFTER INSERT ON `movies` BEGIN INSERT INTO `movies_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "series",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `cache_state` TEXT NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `remote_stale_at` INTEGER NOT NULL, `catalog_origin` TEXT NOT NULL, `episode_playback_template_url` TEXT, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "cacheState",+ "columnName": "cache_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteStaleAt",+ "columnName": "remote_stale_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catalogOrigin",+ "columnName": "catalog_origin",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodePlaybackTemplateUrl",+ "columnName": "episode_playback_template_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_series_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_provider_id_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`)"+ },+ {+ "name": "index_series_provider_id_series_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_series_provider_id_series_id` ON `${TABLE_NAME}` (`provider_id`, `series_id`)"+ },+ {+ "name": "index_series_provider_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_category_id_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_category_id_name_id` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_rating_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "rating",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_rating_name_id` ON `${TABLE_NAME}` (`provider_id`, `rating`, `name`, `id`)"+ },+ {+ "name": "index_series_provider_id_last_modified_name_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "last_modified",+ "name",+ "id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_provider_id_last_modified_name_id` ON `${TABLE_NAME}` (`provider_id`, `last_modified`, `name`, `id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_fts",+ "createSql": "CREATE VIRTUAL TABLE IF NOT EXISTS `${TABLE_NAME}` USING FTS4(`name` TEXT NOT NULL, content=`series`)",+ "fields": [+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": []+ },+ "ftsVersion": "FTS4",+ "ftsOptions": {+ "tokenizer": "simple",+ "tokenizerArgs": [],+ "contentTable": "series",+ "languageIdColumnName": "",+ "matchInfo": "FTS4",+ "notIndexedColumns": [],+ "prefixSizes": [],+ "preferredOrder": "ASC"+ },+ "contentSyncTriggers": [+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_UPDATE BEFORE UPDATE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_BEFORE_DELETE BEFORE DELETE ON `series` BEGIN DELETE FROM `series_fts` WHERE `docid`=OLD.`rowid`; END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_UPDATE AFTER UPDATE ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END",+ "CREATE TRIGGER IF NOT EXISTS room_fts_content_sync_series_fts_AFTER_INSERT AFTER INSERT ON `series` BEGIN INSERT INTO `series_fts`(`docid`, `name`) VALUES (NEW.`rowid`, NEW.`name`); END"+ ]+ },+ {+ "tableName": "episodes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `episode_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `episode_number` INTEGER NOT NULL, `season_number` INTEGER NOT NULL, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `cover_url` TEXT, `plot` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `release_date` TEXT, `series_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `watch_progress` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`series_id`) REFERENCES `series`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "episodeId",+ "columnName": "episode_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "coverUrl",+ "columnName": "cover_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchProgress",+ "columnName": "watch_progress",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_episodes_series_id",+ "unique": false,+ "columnNames": [+ "series_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_series_id` ON `${TABLE_NAME}` (`series_id`)"+ },+ {+ "name": "index_episodes_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_episodes_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_episodes_provider_id_episode_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "episode_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_episodes_provider_id_episode_id` ON `${TABLE_NAME}` (`provider_id`, `episode_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "series",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "series_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "categories",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `is_user_protected` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isUserProtected",+ "columnName": "is_user_protected",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_categories_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_categories_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_categories_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ },+ {+ "name": "index_categories_provider_id_category_id_type",+ "unique": true,+ "columnNames": [+ "provider_id",+ "category_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_categories_provider_id_category_id_type` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `logo_url` TEXT, `group_title` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `epg_channel_id` TEXT, `number` INTEGER NOT NULL, `catch_up_supported` INTEGER NOT NULL, `catch_up_days` INTEGER NOT NULL, `catchUpSource` TEXT, `is_adult` INTEGER NOT NULL, `logical_group_id` TEXT NOT NULL, `error_count` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "logoUrl",+ "columnName": "logo_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "groupTitle",+ "columnName": "group_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgChannelId",+ "columnName": "epg_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "number",+ "columnName": "number",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSupported",+ "columnName": "catch_up_supported",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpDays",+ "columnName": "catch_up_days",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "catchUpSource",+ "columnName": "catchUpSource",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "logicalGroupId",+ "columnName": "logical_group_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorCount",+ "columnName": "error_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_channel_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `stream_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `stream_url` TEXT NOT NULL, `container_extension` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `duration` TEXT, `duration_seconds` INTEGER NOT NULL, `rating` REAL NOT NULL, `year` TEXT, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, `added_at` INTEGER NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `stream_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "duration",+ "columnName": "duration",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "durationSeconds",+ "columnName": "duration_seconds",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "year",+ "columnName": "year",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "stream_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_movie_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `series_id` INTEGER NOT NULL, `provider_series_id` TEXT, `provider_series_key` TEXT NOT NULL, `name` TEXT NOT NULL, `poster_url` TEXT, `backdrop_url` TEXT, `category_id` INTEGER, `category_name` TEXT, `plot` TEXT, `cast` TEXT, `director` TEXT, `genre` TEXT, `release_date` TEXT, `rating` REAL NOT NULL, `tmdb_id` INTEGER, `youtube_trailer` TEXT, `episode_run_time` TEXT, `last_modified` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `provider_series_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerSeriesId",+ "columnName": "provider_series_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "providerSeriesKey",+ "columnName": "provider_series_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "backdropUrl",+ "columnName": "backdrop_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "plot",+ "columnName": "plot",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "cast",+ "columnName": "cast",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "director",+ "columnName": "director",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "releaseDate",+ "columnName": "release_date",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "youtubeTrailer",+ "columnName": "youtube_trailer",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeRunTime",+ "columnName": "episode_run_time",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModified",+ "columnName": "last_modified",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "provider_series_key"+ ]+ },+ "indices": [+ {+ "name": "index_series_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_series_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "category_import_stage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` INTEGER, `type` TEXT NOT NULL, `provider_order` INTEGER NOT NULL DEFAULT 0, `is_adult` INTEGER NOT NULL, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`session_id`, `provider_id`, `category_id`, `type`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "sessionId",+ "columnName": "session_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "parentId",+ "columnName": "parent_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "type",+ "columnName": "type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerOrder",+ "columnName": "provider_order",+ "affinity": "INTEGER",+ "notNull": true,+ "defaultValue": "0"+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "session_id",+ "provider_id",+ "category_id",+ "type"+ ]+ },+ "indices": [+ {+ "name": "index_category_import_stage_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_category_import_stage_session_id_provider_id",+ "unique": false,+ "columnNames": [+ "session_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_session_id_provider_id` ON `${TABLE_NAME}` (`session_id`, `provider_id`)"+ },+ {+ "name": "index_category_import_stage_provider_id_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_category_import_stage_provider_id_type` ON `${TABLE_NAME}` (`provider_id`, `type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "programs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `title` TEXT NOT NULL, `description` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `genre` TEXT, `category` TEXT, `has_archive` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "genre",+ "columnName": "genre",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "hasArchive",+ "columnName": "has_archive",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_programs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_programs_provider_id_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id` ON `${TABLE_NAME}` (`provider_id`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_end_time_channel_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "end_time",+ "channel_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_end_time_channel_id` ON `${TABLE_NAME}` (`provider_id`, `end_time`, `channel_id`)"+ },+ {+ "name": "index_programs_provider_id_start_time_end_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_programs_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_start_time` ON `${TABLE_NAME}` (`start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`)"+ },+ {+ "name": "index_programs_provider_id_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_programs_provider_id_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `start_time`, `end_time`)"+ }+ ]+ },+ {+ "tableName": "favorites",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `position` INTEGER NOT NULL, `group_id` INTEGER, `group_key` INTEGER NOT NULL, `added_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`group_id`) REFERENCES `virtual_groups`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupId",+ "columnName": "group_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_favorites_provider_id_content_id_content_type_group_key",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_id",+ "content_type",+ "group_key"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_favorites_provider_id_content_id_content_type_group_key` ON `${TABLE_NAME}` (`provider_id`, `content_id`, `content_type`, `group_key`)"+ },+ {+ "name": "index_favorites_provider_id_content_type_group_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "group_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_provider_id_content_type_group_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `group_id`)"+ },+ {+ "name": "index_favorites_group_id_position",+ "unique": false,+ "columnNames": [+ "group_id",+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_favorites_group_id_position` ON `${TABLE_NAME}` (`group_id`, `position`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "virtual_groups",+ "onDelete": "SET NULL",+ "onUpdate": "NO ACTION",+ "columns": [+ "group_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "virtual_groups",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `name` TEXT NOT NULL, `icon_emoji` TEXT, `position` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `content_type` TEXT NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconEmoji",+ "columnName": "icon_emoji",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "position",+ "columnName": "position",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_virtual_groups_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_virtual_groups_position",+ "unique": false,+ "columnNames": [+ "position"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_position` ON `${TABLE_NAME}` (`position`)"+ },+ {+ "name": "index_virtual_groups_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_virtual_groups_content_type` ON `${TABLE_NAME}` (`content_type`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "playback_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `content_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `title` TEXT NOT NULL, `poster_url` TEXT, `stream_url` TEXT NOT NULL, `resume_position_ms` INTEGER NOT NULL, `total_duration_ms` INTEGER NOT NULL, `last_watched_at` INTEGER NOT NULL, `watch_count` INTEGER NOT NULL, `watched_status` TEXT NOT NULL, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resumePositionMs",+ "columnName": "resume_position_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalDurationMs",+ "columnName": "total_duration_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastWatchedAt",+ "columnName": "last_watched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchCount",+ "columnName": "watch_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "watchedStatus",+ "columnName": "watched_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_history_content_id_content_type_provider_id",+ "unique": true,+ "columnNames": [+ "content_id",+ "content_type",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_history_content_id_content_type_provider_id` ON `${TABLE_NAME}` (`content_id`, `content_type`, `provider_id`)"+ },+ {+ "name": "index_playback_history_last_watched_at",+ "unique": false,+ "columnNames": [+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_last_watched_at` ON `${TABLE_NAME}` (`last_watched_at`)"+ },+ {+ "name": "index_playback_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `content_id`)"+ },+ {+ "name": "index_playback_history_provider_id_content_type_last_watched_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "last_watched_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_history_provider_id_content_type_last_watched_at` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `last_watched_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "tmdb_identity",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tmdb_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `canonical_provider_id` INTEGER NOT NULL, `first_seen_at` INTEGER NOT NULL, PRIMARY KEY(`tmdb_id`, `content_type`), FOREIGN KEY(`canonical_provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "tmdbId",+ "columnName": "tmdb_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "canonicalProviderId",+ "columnName": "canonical_provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "firstSeenAt",+ "columnName": "first_seen_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "tmdb_id",+ "content_type"+ ]+ },+ "indices": [+ {+ "name": "index_tmdb_identity_content_type",+ "unique": false,+ "columnNames": [+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_content_type` ON `${TABLE_NAME}` (`content_type`)"+ },+ {+ "name": "index_tmdb_identity_canonical_provider_id",+ "unique": false,+ "columnNames": [+ "canonical_provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_tmdb_identity_canonical_provider_id` ON `${TABLE_NAME}` (`canonical_provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "canonical_provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "search_history",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `query` TEXT NOT NULL, `content_scope` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `used_at` INTEGER NOT NULL, `use_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "query",+ "columnName": "query",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentScope",+ "columnName": "content_scope",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "usedAt",+ "columnName": "used_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "useCount",+ "columnName": "use_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_search_history_content_scope_provider_id_used_at",+ "unique": false,+ "columnNames": [+ "content_scope",+ "provider_id",+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_content_scope_provider_id_used_at` ON `${TABLE_NAME}` (`content_scope`, `provider_id`, `used_at`)"+ },+ {+ "name": "index_search_history_used_at",+ "unique": false,+ "columnNames": [+ "used_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_used_at` ON `${TABLE_NAME}` (`used_at`)"+ },+ {+ "name": "index_search_history_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_search_history_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_search_history_query_content_scope_provider_id",+ "unique": true,+ "columnNames": [+ "query",+ "content_scope",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_search_history_query_content_scope_provider_id` ON `${TABLE_NAME}` (`query`, `content_scope`, `provider_id`)"+ }+ ]+ },+ {+ "tableName": "sync_metadata",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `last_live_sync` INTEGER NOT NULL, `last_live_success` INTEGER NOT NULL, `last_movie_sync` INTEGER NOT NULL, `last_series_sync` INTEGER NOT NULL, `last_series_success` INTEGER NOT NULL, `last_epg_sync` INTEGER NOT NULL, `last_epg_success` INTEGER NOT NULL, `last_movie_attempt` INTEGER NOT NULL, `last_movie_success` INTEGER NOT NULL, `last_movie_partial` INTEGER NOT NULL, `live_count` INTEGER NOT NULL, `movie_count` INTEGER NOT NULL, `series_count` INTEGER NOT NULL, `epg_count` INTEGER NOT NULL, `last_sync_status` TEXT NOT NULL, `movie_sync_mode` TEXT NOT NULL, `movie_warnings_count` INTEGER NOT NULL, `movie_catalog_stale` INTEGER NOT NULL, `live_avoid_full_until` INTEGER NOT NULL, `movie_avoid_full_until` INTEGER NOT NULL, `series_avoid_full_until` INTEGER NOT NULL, `live_sequential_failures_remembered` INTEGER NOT NULL, `live_healthy_sync_streak` INTEGER NOT NULL, `movie_parallel_failures_remembered` INTEGER NOT NULL, `movie_healthy_sync_streak` INTEGER NOT NULL, `series_sequential_failures_remembered` INTEGER NOT NULL, `series_healthy_sync_streak` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSync",+ "columnName": "last_live_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLiveSuccess",+ "columnName": "last_live_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSync",+ "columnName": "last_movie_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSync",+ "columnName": "last_series_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSeriesSuccess",+ "columnName": "last_series_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSync",+ "columnName": "last_epg_sync",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastEpgSuccess",+ "columnName": "last_epg_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieAttempt",+ "columnName": "last_movie_attempt",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMovieSuccess",+ "columnName": "last_movie_success",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastMoviePartial",+ "columnName": "last_movie_partial",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveCount",+ "columnName": "live_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCount",+ "columnName": "movie_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesCount",+ "columnName": "series_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgCount",+ "columnName": "epg_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSyncStatus",+ "columnName": "last_sync_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieSyncMode",+ "columnName": "movie_sync_mode",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "movieWarningsCount",+ "columnName": "movie_warnings_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieCatalogStale",+ "columnName": "movie_catalog_stale",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveAvoidFullUntil",+ "columnName": "live_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieAvoidFullUntil",+ "columnName": "movie_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesAvoidFullUntil",+ "columnName": "series_avoid_full_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveSequentialFailuresRemembered",+ "columnName": "live_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "liveHealthySyncStreak",+ "columnName": "live_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieParallelFailuresRemembered",+ "columnName": "movie_parallel_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "movieHealthySyncStreak",+ "columnName": "movie_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesSequentialFailuresRemembered",+ "columnName": "series_sequential_failures_remembered",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "seriesHealthySyncStreak",+ "columnName": "series_healthy_sync_streak",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "movie_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_movie_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_movie_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "series_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `is_complete` INTEGER NOT NULL, `page_size` INTEGER NOT NULL, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_series_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_series_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_category_hydration",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `last_loaded_page` INTEGER NOT NULL, `last_attempted_page` INTEGER NOT NULL, `last_successful_page` INTEGER NOT NULL, `total_pages` INTEGER NOT NULL, `advertised_total_items` INTEGER, `advertised_total_pages` INTEGER, `page_size` INTEGER NOT NULL, `item_count` INTEGER NOT NULL, `is_complete` INTEGER NOT NULL, `has_movies` INTEGER NOT NULL, `has_series` INTEGER NOT NULL, `last_hydrated_at` INTEGER NOT NULL, `last_status` TEXT NOT NULL, `last_error` TEXT, `retry_after_ms` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `retry_budget_remaining` INTEGER NOT NULL, `last_page_fingerprint` TEXT, PRIMARY KEY(`provider_id`, `category_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastLoadedPage",+ "columnName": "last_loaded_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastAttemptedPage",+ "columnName": "last_attempted_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessfulPage",+ "columnName": "last_successful_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalPages",+ "columnName": "total_pages",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "advertisedTotalItems",+ "columnName": "advertised_total_items",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "advertisedTotalPages",+ "columnName": "advertised_total_pages",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "pageSize",+ "columnName": "page_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "itemCount",+ "columnName": "item_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isComplete",+ "columnName": "is_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasMovies",+ "columnName": "has_movies",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "hasSeries",+ "columnName": "has_series",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastHydratedAt",+ "columnName": "last_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastStatus",+ "columnName": "last_status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "retryAfterMs",+ "columnName": "retry_after_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryBudgetRemaining",+ "columnName": "retry_budget_remaining",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastPageFingerprint",+ "columnName": "last_page_fingerprint",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_category_hydration_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_category_hydration_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "vod_catalog_entries",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `category_id` INTEGER NOT NULL, `raw_item_id` TEXT NOT NULL, `item_type` TEXT NOT NULL, `target_id` INTEGER NOT NULL, `raw_page` INTEGER NOT NULL, `raw_index` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `category_id`, `raw_item_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawItemId",+ "columnName": "raw_item_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "itemType",+ "columnName": "item_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawPage",+ "columnName": "raw_page",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "rawIndex",+ "columnName": "raw_index",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_item_id"+ ]+ },+ "indices": [+ {+ "name": "index_vod_catalog_entries_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index",+ "unique": false,+ "columnNames": [+ "provider_id",+ "category_id",+ "raw_page",+ "raw_index"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_category_id_raw_page_raw_index` ON `${TABLE_NAME}` (`provider_id`, `category_id`, `raw_page`, `raw_index`)"+ },+ {+ "name": "index_vod_catalog_entries_provider_id_item_type_target_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "item_type",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_vod_catalog_entries_provider_id_item_type_target_id` ON `${TABLE_NAME}` (`provider_id`, `item_type`, `target_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `url` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `last_refresh_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `last_error` TEXT, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `etag` TEXT, `last_modified_header` TEXT, `timezone_policy` TEXT NOT NULL, `timezone_id` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "url",+ "columnName": "url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastRefreshAt",+ "columnName": "last_refresh_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "etag",+ "columnName": "etag",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastModifiedHeader",+ "columnName": "last_modified_header",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "timezonePolicy",+ "columnName": "timezone_policy",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "timezoneId",+ "columnName": "timezone_id",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_sources_url",+ "unique": true,+ "columnNames": [+ "url"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_sources_url` ON `${TABLE_NAME}` (`url`)"+ }+ ]+ },+ {+ "tableName": "provider_epg_sources",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `epg_source_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_epg_sources_provider_id_epg_source_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_epg_sources_provider_id_epg_source_id` ON `${TABLE_NAME}` (`provider_id`, `epg_source_id`)"+ },+ {+ "name": "index_provider_epg_sources_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_epg_sources_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_channels",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `display_name` TEXT NOT NULL, `normalized_name` TEXT NOT NULL, `icon_url` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "normalizedName",+ "columnName": "normalized_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "iconUrl",+ "columnName": "icon_url",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_channels_epg_source_id_xmltv_channel_id",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id_xmltv_channel_id` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`)"+ },+ {+ "name": "index_epg_channels_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_channels_normalized_name",+ "unique": false,+ "columnNames": [+ "normalized_name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_channels_normalized_name` ON `${TABLE_NAME}` (`normalized_name`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "epg_programmes",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `epg_source_id` INTEGER NOT NULL, `xmltv_channel_id` TEXT NOT NULL, `start_time` INTEGER NOT NULL, `end_time` INTEGER NOT NULL, `title` TEXT NOT NULL, `subtitle` TEXT, `description` TEXT NOT NULL, `category` TEXT, `lang` TEXT NOT NULL, `rating` TEXT, `image_url` TEXT, `episode_info` TEXT, FOREIGN KEY(`epg_source_id`) REFERENCES `epg_sources`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "startTime",+ "columnName": "start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endTime",+ "columnName": "end_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "title",+ "columnName": "title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "subtitle",+ "columnName": "subtitle",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "description",+ "columnName": "description",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "category",+ "columnName": "category",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lang",+ "columnName": "lang",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "episodeInfo",+ "columnName": "episode_info",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time",+ "unique": false,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time",+ "unique": true,+ "columnNames": [+ "epg_source_id",+ "xmltv_channel_id",+ "start_time",+ "end_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id_xmltv_channel_id_start_time_end_time` ON `${TABLE_NAME}` (`epg_source_id`, `xmltv_channel_id`, `start_time`, `end_time`)"+ },+ {+ "name": "index_epg_programmes_epg_source_id",+ "unique": false,+ "columnNames": [+ "epg_source_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_epg_source_id` ON `${TABLE_NAME}` (`epg_source_id`)"+ },+ {+ "name": "index_epg_programmes_start_time",+ "unique": false,+ "columnNames": [+ "start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_epg_programmes_start_time` ON `${TABLE_NAME}` (`start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "epg_sources",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "epg_source_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "channel_epg_mappings",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_channel_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `source_type` TEXT NOT NULL, `epg_source_id` INTEGER, `xmltv_channel_id` TEXT, `match_type` TEXT, `confidence` REAL NOT NULL, `matched_at` INTEGER NOT NULL, `failed_attempts` INTEGER NOT NULL, `source` TEXT, `is_manual_override` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerChannelId",+ "columnName": "provider_channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "epgSourceId",+ "columnName": "epg_source_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "xmltvChannelId",+ "columnName": "xmltv_channel_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "matchType",+ "columnName": "match_type",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "confidence",+ "columnName": "confidence",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "matchedAt",+ "columnName": "matched_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedAttempts",+ "columnName": "failed_attempts",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "source",+ "columnName": "source",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "isManualOverride",+ "columnName": "is_manual_override",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_channel_epg_mappings_provider_id_provider_channel_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "provider_channel_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id_provider_channel_id` ON `${TABLE_NAME}` (`provider_id`, `provider_channel_id`)"+ },+ {+ "name": "index_channel_epg_mappings_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_channel_epg_mappings_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "combined_m3u_profiles",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "combined_m3u_profile_members",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `profile_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`profile_id`) REFERENCES `combined_m3u_profiles`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "profileId",+ "columnName": "profile_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_combined_m3u_profile_members_profile_id",+ "unique": false,+ "columnNames": [+ "profile_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id` ON `${TABLE_NAME}` (`profile_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_combined_m3u_profile_members_profile_id_provider_id",+ "unique": true,+ "columnNames": [+ "profile_id",+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_combined_m3u_profile_members_profile_id_provider_id` ON `${TABLE_NAME}` (`profile_id`, `provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "combined_m3u_profiles",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "profile_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_schedules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `requested_start_ms` INTEGER NOT NULL, `requested_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `enabled` INTEGER NOT NULL, `is_manual` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "requestedStartMs",+ "columnName": "requested_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "requestedEndMs",+ "columnName": "requested_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "enabled",+ "columnName": "enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isManual",+ "columnName": "is_manual",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_schedules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_schedules_enabled_requested_start_ms",+ "unique": false,+ "columnNames": [+ "enabled",+ "requested_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_enabled_requested_start_ms` ON `${TABLE_NAME}` (`enabled`, `requested_start_ms`)"+ },+ {+ "name": "index_recording_schedules_recurring_rule_id",+ "unique": false,+ "columnNames": [+ "recurring_rule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_schedules_recurring_rule_id` ON `${TABLE_NAME}` (`recurring_rule_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_runs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `schedule_id` INTEGER NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` INTEGER NOT NULL, `channel_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `program_title` TEXT, `scheduled_start_ms` INTEGER NOT NULL, `scheduled_end_ms` INTEGER NOT NULL, `recurrence` TEXT NOT NULL, `recurring_rule_id` TEXT, `status` TEXT NOT NULL, `source_type` TEXT NOT NULL, `resolved_url` TEXT, `headers_json` TEXT NOT NULL, `user_agent` TEXT, `expiration_time` INTEGER, `provider_label` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `bytes_written` INTEGER NOT NULL, `average_throughput_bps` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `last_progress_at_ms` INTEGER, `failure_category` TEXT NOT NULL, `failure_reason` TEXT, `terminal_at_ms` INTEGER, `started_at_ms` INTEGER, `ended_at_ms` INTEGER, `schedule_enabled` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `alarm_start_at_ms` INTEGER, `alarm_stop_at_ms` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`), FOREIGN KEY(`schedule_id`) REFERENCES `recording_schedules`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "scheduleId",+ "columnName": "schedule_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "scheduledStartMs",+ "columnName": "scheduled_start_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "scheduledEndMs",+ "columnName": "scheduled_end_ms",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "recurrence",+ "columnName": "recurrence",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "recurringRuleId",+ "columnName": "recurring_rule_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceType",+ "columnName": "source_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolvedUrl",+ "columnName": "resolved_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "headersJson",+ "columnName": "headers_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "userAgent",+ "columnName": "user_agent",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "expirationTime",+ "columnName": "expiration_time",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "providerLabel",+ "columnName": "provider_label",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "averageThroughputBytesPerSecond",+ "columnName": "average_throughput_bps",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastProgressAtMs",+ "columnName": "last_progress_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureCategory",+ "columnName": "failure_category",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "terminalAtMs",+ "columnName": "terminal_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "startedAtMs",+ "columnName": "started_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "endedAtMs",+ "columnName": "ended_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "scheduleEnabled",+ "columnName": "schedule_enabled",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "alarmStartAtMs",+ "columnName": "alarm_start_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "alarmStopAtMs",+ "columnName": "alarm_stop_at_ms",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_recording_runs_schedule_id",+ "unique": false,+ "columnNames": [+ "schedule_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_schedule_id` ON `${TABLE_NAME}` (`schedule_id`)"+ },+ {+ "name": "index_recording_runs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_recording_runs_status_scheduled_start_ms",+ "unique": false,+ "columnNames": [+ "status",+ "scheduled_start_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_status_scheduled_start_ms` ON `${TABLE_NAME}` (`status`, `scheduled_start_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_start_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_start_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_start_at_ms` ON `${TABLE_NAME}` (`alarm_start_at_ms`)"+ },+ {+ "name": "index_recording_runs_alarm_stop_at_ms",+ "unique": false,+ "columnNames": [+ "alarm_stop_at_ms"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_recording_runs_alarm_stop_at_ms` ON `${TABLE_NAME}` (`alarm_stop_at_ms`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "recording_schedules",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "schedule_id"+ ],+ "referencedColumns": [+ "id"+ ]+ },+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "program_reminders",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `channel_id` TEXT NOT NULL, `channel_name` TEXT NOT NULL, `program_title` TEXT NOT NULL, `program_start_time` INTEGER NOT NULL, `remind_at` INTEGER NOT NULL, `lead_time_minutes` INTEGER NOT NULL, `is_dismissed` INTEGER NOT NULL, `notified_at` INTEGER, `exact_alarm_armed` INTEGER NOT NULL, `delivery_state` TEXT NOT NULL, `delivery_attempt_token` TEXT, `delivery_attempted_at` INTEGER, `delivery_attempt_count` INTEGER NOT NULL, `delivery_failure_reason` TEXT, `created_at` INTEGER NOT NULL, FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "channelId",+ "columnName": "channel_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelName",+ "columnName": "channel_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programTitle",+ "columnName": "program_title",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "programStartTime",+ "columnName": "program_start_time",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remindAt",+ "columnName": "remind_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "leadTimeMinutes",+ "columnName": "lead_time_minutes",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isDismissed",+ "columnName": "is_dismissed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "notifiedAt",+ "columnName": "notified_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "exactAlarmArmed",+ "columnName": "exact_alarm_armed",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryState",+ "columnName": "delivery_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deliveryAttemptToken",+ "columnName": "delivery_attempt_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "deliveryAttemptedAt",+ "columnName": "delivery_attempted_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "deliveryAttemptCount",+ "columnName": "delivery_attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deliveryFailureReason",+ "columnName": "delivery_failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_program_reminders_provider_id_remind_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_remind_at` ON `${TABLE_NAME}` (`provider_id`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_is_dismissed_notified_at_remind_at",+ "unique": false,+ "columnNames": [+ "is_dismissed",+ "notified_at",+ "remind_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_is_dismissed_notified_at_remind_at` ON `${TABLE_NAME}` (`is_dismissed`, `notified_at`, `remind_at`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_start_time",+ "unique": false,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_start_time`)"+ },+ {+ "name": "index_program_reminders_provider_id_channel_id_program_title_program_start_time",+ "unique": true,+ "columnNames": [+ "provider_id",+ "channel_id",+ "program_title",+ "program_start_time"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_program_reminders_provider_id_channel_id_program_title_program_start_time` ON `${TABLE_NAME}` (`provider_id`, `channel_id`, `program_title`, `program_start_time`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "recording_storage",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `tree_uri` TEXT, `display_name` TEXT, `output_directory` TEXT, `available_bytes` INTEGER, `is_writable` INTEGER NOT NULL, `file_name_pattern` TEXT NOT NULL, `retention_days` INTEGER, `max_simultaneous_recordings` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "treeUri",+ "columnName": "tree_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "displayName",+ "columnName": "display_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDirectory",+ "columnName": "output_directory",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "availableBytes",+ "columnName": "available_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "isWritable",+ "columnName": "is_writable",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "fileNamePattern",+ "columnName": "file_name_pattern",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "retentionDays",+ "columnName": "retention_days",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "maxSimultaneousRecordings",+ "columnName": "max_simultaneous_recordings",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ }+ },+ {+ "tableName": "playback_compatibility_records",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_fingerprint` TEXT NOT NULL, `device_model` TEXT NOT NULL, `android_sdk` INTEGER NOT NULL, `stream_type` TEXT NOT NULL, `video_mime_type` TEXT NOT NULL, `resolution_bucket` TEXT NOT NULL, `decoder_name` TEXT NOT NULL, `surface_type` TEXT NOT NULL, `failure_type` TEXT NOT NULL, `last_failed_at` INTEGER NOT NULL, `last_succeeded_at` INTEGER NOT NULL, `failure_count` INTEGER NOT NULL, `success_count` INTEGER NOT NULL)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deviceFingerprint",+ "columnName": "device_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "deviceModel",+ "columnName": "device_model",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "androidSdk",+ "columnName": "android_sdk",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "streamType",+ "columnName": "stream_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "videoMimeType",+ "columnName": "video_mime_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "resolutionBucket",+ "columnName": "resolution_bucket",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "decoderName",+ "columnName": "decoder_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surfaceType",+ "columnName": "surface_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "failureType",+ "columnName": "failure_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "lastFailedAt",+ "columnName": "last_failed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSucceededAt",+ "columnName": "last_succeeded_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failureCount",+ "columnName": "failure_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "successCount",+ "columnName": "success_count",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type",+ "unique": true,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket",+ "decoder_name",+ "surface_type"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket_decoder_name_surface_type` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`, `decoder_name`, `surface_type`)"+ },+ {+ "name": "index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket",+ "unique": false,+ "columnNames": [+ "device_fingerprint",+ "stream_type",+ "video_mime_type",+ "resolution_bucket"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_device_fingerprint_stream_type_video_mime_type_resolution_bucket` ON `${TABLE_NAME}` (`device_fingerprint`, `stream_type`, `video_mime_type`, `resolution_bucket`)"+ },+ {+ "name": "index_playback_compatibility_records_last_failed_at",+ "unique": false,+ "columnNames": [+ "last_failed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_failed_at` ON `${TABLE_NAME}` (`last_failed_at`)"+ },+ {+ "name": "index_playback_compatibility_records_last_succeeded_at",+ "unique": false,+ "columnNames": [+ "last_succeeded_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_playback_compatibility_records_last_succeeded_at` ON `${TABLE_NAME}` (`last_succeeded_at`)"+ }+ ]+ },+ {+ "tableName": "xtream_content_index",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `remote_id` TEXT NOT NULL, `local_content_id` INTEGER, `name` TEXT NOT NULL, `category_id` INTEGER, `category_name` TEXT, `image_url` TEXT, `container_extension` TEXT, `rating` REAL NOT NULL, `added_at` INTEGER NOT NULL, `remote_updated_at` INTEGER NOT NULL, `is_adult` INTEGER NOT NULL, `indexed_at` INTEGER NOT NULL, `detail_hydrated_at` INTEGER NOT NULL, `stale_state` TEXT NOT NULL, `error_state` TEXT, `sync_fingerprint` TEXT NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `remote_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "remoteId",+ "columnName": "remote_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "localContentId",+ "columnName": "local_content_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "name",+ "columnName": "name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoryId",+ "columnName": "category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "categoryName",+ "columnName": "category_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "imageUrl",+ "columnName": "image_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "rating",+ "columnName": "rating",+ "affinity": "REAL",+ "notNull": true+ },+ {+ "fieldPath": "addedAt",+ "columnName": "added_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "remoteUpdatedAt",+ "columnName": "remote_updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "isAdult",+ "columnName": "is_adult",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedAt",+ "columnName": "indexed_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "detailHydratedAt",+ "columnName": "detail_hydrated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "staleState",+ "columnName": "stale_state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "errorState",+ "columnName": "error_state",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncFingerprint",+ "columnName": "sync_fingerprint",+ "affinity": "TEXT",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "remote_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_content_index_provider_id_content_type",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type` ON `${TABLE_NAME}` (`provider_id`, `content_type`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_category_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "category_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_category_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `category_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_name",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "name"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_name` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `name`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_content_type_local_content_id",+ "unique": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "local_content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_content_type_local_content_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `local_content_id`)"+ },+ {+ "name": "index_xtream_content_index_provider_id_indexed_at",+ "unique": false,+ "columnNames": [+ "provider_id",+ "indexed_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_provider_id_indexed_at` ON `${TABLE_NAME}` (`provider_id`, `indexed_at`)"+ },+ {+ "name": "index_xtream_content_index_stale_state",+ "unique": false,+ "columnNames": [+ "stale_state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_content_index_stale_state` ON `${TABLE_NAME}` (`stale_state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `priority_category_id` INTEGER, `priority_requested_at` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "priorityCategoryId",+ "columnName": "priority_category_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "priorityRequestedAt",+ "columnName": "priority_requested_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_index_jobs_section",+ "unique": false,+ "columnNames": [+ "section"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_section` ON `${TABLE_NAME}` (`section`)"+ },+ {+ "name": "index_xtream_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_xtream_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "xtream_live_onboarding_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `provider_type` TEXT NOT NULL, `content_type` TEXT NOT NULL, `phase` TEXT NOT NULL, `staged_session_id` INTEGER, `import_strategy` TEXT, `next_category_index` INTEGER NOT NULL, `accepted_row_count` INTEGER NOT NULL, `staged_flush_count` INTEGER NOT NULL, `sync_profile_tier` TEXT, `sync_profile_batch_size` INTEGER NOT NULL, `sync_profile_strategy` TEXT, `sync_profile_low_memory` INTEGER NOT NULL, `sync_profile_memory_class_mb` INTEGER NOT NULL, `sync_profile_available_mem_mb` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerType",+ "columnName": "provider_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "stagedSessionId",+ "columnName": "staged_session_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "importStrategy",+ "columnName": "import_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "acceptedRowCount",+ "columnName": "accepted_row_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stagedFlushCount",+ "columnName": "staged_flush_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileTier",+ "columnName": "sync_profile_tier",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileBatchSize",+ "columnName": "sync_profile_batch_size",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileStrategy",+ "columnName": "sync_profile_strategy",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "syncProfileLowMemory",+ "columnName": "sync_profile_low_memory",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileMemoryClassMb",+ "columnName": "sync_profile_memory_class_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "syncProfileAvailableMemMb",+ "columnName": "sync_profile_available_mem_mb",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_xtream_live_onboarding_state_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_phase",+ "unique": false,+ "columnNames": [+ "phase"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_phase` ON `${TABLE_NAME}` (`phase`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_xtream_live_onboarding_state_staged_session_id",+ "unique": false,+ "columnNames": [+ "staged_session_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_xtream_live_onboarding_state_staged_session_id` ON `${TABLE_NAME}` (`staged_session_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_index_jobs",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `section` TEXT NOT NULL, `state` TEXT NOT NULL, `total_categories` INTEGER NOT NULL, `completed_categories` INTEGER NOT NULL, `next_category_index` INTEGER NOT NULL, `failed_categories` INTEGER NOT NULL, `indexed_rows` INTEGER NOT NULL, `skipped_malformed_rows` INTEGER NOT NULL, `deleted_pruned_rows` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER NOT NULL, `last_success_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `section`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "section",+ "columnName": "section",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "totalCategories",+ "columnName": "total_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedCategories",+ "columnName": "completed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "nextCategoryIndex",+ "columnName": "next_category_index",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "failedCategories",+ "columnName": "failed_categories",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "indexedRows",+ "columnName": "indexed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "skippedMalformedRows",+ "columnName": "skipped_malformed_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "deletedPrunedRows",+ "columnName": "deleted_pruned_rows",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastAttemptAt",+ "columnName": "last_attempt_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastSuccessAt",+ "columnName": "last_success_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "section"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_index_jobs_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_index_jobs_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_stalker_index_jobs_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_index_jobs_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_portal_state",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `working_endpoint` TEXT, `bootstrap_recipe` TEXT, `bulk_live_supported` INTEGER, `bulk_live_category_fidelity` INTEGER, `movie_wildcard_supported` INTEGER, `series_wildcard_supported` INTEGER, `epg_supported` INTEGER, `safe_metadata_concurrency` INTEGER NOT NULL, `stress_cooldown_until` INTEGER NOT NULL, `endpoint_health_json` TEXT NOT NULL, `endpoint_failed_until` INTEGER NOT NULL, `validated_at` INTEGER NOT NULL, `schema_version` INTEGER NOT NULL, `configuration_generation` INTEGER NOT NULL, `learning_json` TEXT NOT NULL, `observation_source` TEXT NOT NULL, `observed_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "workingEndpoint",+ "columnName": "working_endpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bootstrapRecipe",+ "columnName": "bootstrap_recipe",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "bulkLiveSupported",+ "columnName": "bulk_live_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "bulkLiveCategoryFidelity",+ "columnName": "bulk_live_category_fidelity",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "movieWildcardSupported",+ "columnName": "movie_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesWildcardSupported",+ "columnName": "series_wildcard_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "epgSupported",+ "columnName": "epg_supported",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "safeMetadataConcurrency",+ "columnName": "safe_metadata_concurrency",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "stressCooldownUntil",+ "columnName": "stress_cooldown_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "endpointHealthJson",+ "columnName": "endpoint_health_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "endpointFailedUntil",+ "columnName": "endpoint_failed_until",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "validatedAt",+ "columnName": "validated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schemaVersion",+ "columnName": "schema_version",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "learningJson",+ "columnName": "learning_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observationSource",+ "columnName": "observation_source",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "observedAt",+ "columnName": "observed_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_portal_state_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_portal_state_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_remote_identities",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `raw_id` TEXT NOT NULL, `surrogate_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `content_type`, `raw_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "rawId",+ "columnName": "raw_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "surrogateId",+ "columnName": "surrogate_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "content_type",+ "raw_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_remote_identities_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_remote_identities_provider_id_content_type_surrogate_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "content_type",+ "surrogate_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_stalker_remote_identities_provider_id_content_type_surrogate_id` ON `${TABLE_NAME}` (`provider_id`, `content_type`, `surrogate_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "stalker_discovery_staging",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`discovery_id` TEXT NOT NULL, `provider_id` INTEGER, `configuration_generation` INTEGER NOT NULL, `sanitized_summary` TEXT NOT NULL, `categories_json` TEXT NOT NULL, `channels_json` TEXT NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`discovery_id`))",+ "fields": [+ {+ "fieldPath": "discoveryId",+ "columnName": "discovery_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "configurationGeneration",+ "columnName": "configuration_generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sanitizedSummary",+ "columnName": "sanitized_summary",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "categoriesJson",+ "columnName": "categories_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "channelsJson",+ "columnName": "channels_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "discovery_id"+ ]+ },+ "indices": [+ {+ "name": "index_stalker_discovery_staging_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_stalker_discovery_staging_created_at",+ "unique": false,+ "columnNames": [+ "created_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_stalker_discovery_staging_created_at` ON `${TABLE_NAME}` (`created_at`)"+ }+ ]+ },+ {+ "tableName": "downloads",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `content_type` TEXT NOT NULL, `content_id` INTEGER NOT NULL, `content_name` TEXT NOT NULL, `stream_url` TEXT NOT NULL, `source_stream_url` TEXT, `source_stream_id` INTEGER, `container_extension` TEXT, `poster_url` TEXT, `output_uri` TEXT, `output_display_path` TEXT, `status` TEXT NOT NULL, `bytes_written` INTEGER NOT NULL, `total_bytes` INTEGER, `supports_resume` INTEGER NOT NULL, `retry_count` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `completed_at` INTEGER, `failure_reason` TEXT, `owner_id` TEXT, `owner_epoch` INTEGER NOT NULL, `heartbeat_at` INTEGER, `series_id` INTEGER, `season_number` INTEGER, `episode_number` INTEGER, PRIMARY KEY(`id`))",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentType",+ "columnName": "content_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "contentId",+ "columnName": "content_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "contentName",+ "columnName": "content_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamUrl",+ "columnName": "stream_url",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "sourceStreamUrl",+ "columnName": "source_stream_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "sourceStreamId",+ "columnName": "source_stream_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "containerExtension",+ "columnName": "container_extension",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "posterUrl",+ "columnName": "poster_url",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputUri",+ "columnName": "output_uri",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "outputDisplayPath",+ "columnName": "output_display_path",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "status",+ "columnName": "status",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "bytesWritten",+ "columnName": "bytes_written",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "totalBytes",+ "columnName": "total_bytes",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "supportsResume",+ "columnName": "supports_resume",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "retryCount",+ "columnName": "retry_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "failureReason",+ "columnName": "failure_reason",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerId",+ "columnName": "owner_id",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "ownerEpoch",+ "columnName": "owner_epoch",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seriesId",+ "columnName": "series_id",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_downloads_status",+ "unique": false,+ "columnNames": [+ "status"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_status` ON `${TABLE_NAME}` (`status`)"+ },+ {+ "name": "index_downloads_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_downloads_content_type_content_id",+ "unique": false,+ "columnNames": [+ "content_type",+ "content_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_downloads_content_type_content_id` ON `${TABLE_NAME}` (`content_type`, `content_id`)"+ }+ ]+ },+ {+ "tableName": "provider_deletion_cleanup",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `provider_id` INTEGER NOT NULL, `action` TEXT NOT NULL, `target_id` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT)",+ "fields": [+ {+ "fieldPath": "id",+ "columnName": "id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "action",+ "columnName": "action",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetId",+ "columnName": "target_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ }+ ],+ "primaryKey": {+ "autoGenerate": true,+ "columnNames": [+ "id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_deletion_cleanup_provider_id_action_target_id",+ "unique": true,+ "columnNames": [+ "provider_id",+ "action",+ "target_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_provider_deletion_cleanup_provider_id_action_target_id` ON `${TABLE_NAME}` (`provider_id`, `action`, `target_id`)"+ }+ ]+ },+ {+ "tableName": "plugin_provider_ownership",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `service_class_name` TEXT NOT NULL, `manifest_id` TEXT NOT NULL, `provider_id` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, PRIMARY KEY(`package_name`, `service_class_name`, `manifest_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "packageName",+ "columnName": "package_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "serviceClassName",+ "columnName": "service_class_name",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "manifestId",+ "columnName": "manifest_id",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "package_name",+ "service_class_name",+ "manifest_id"+ ]+ },+ "indices": [+ {+ "name": "index_plugin_provider_ownership_provider_id",+ "unique": true,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_plugin_provider_ownership_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_config_revisions",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `revision` INTEGER NOT NULL, `config_json` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `revision`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "revision",+ "columnName": "revision",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "configJson",+ "columnName": "config_json",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "revision"+ ]+ },+ "indices": [+ {+ "name": "index_provider_config_revisions_provider_id_state",+ "unique": false,+ "columnNames": [+ "provider_id",+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_config_revisions_provider_id_state` ON `${TABLE_NAME}` (`provider_id`, `state`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "backup_restore_checkpoints",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`restore_key` TEXT NOT NULL, `room_complete` INTEGER NOT NULL, `preferences_complete` INTEGER NOT NULL, `presets_complete` INTEGER NOT NULL, `schedules_complete` INTEGER NOT NULL, `state` TEXT NOT NULL, `preference_snapshot_json` TEXT, `last_error` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`restore_key`))",+ "fields": [+ {+ "fieldPath": "restoreKey",+ "columnName": "restore_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "roomComplete",+ "columnName": "room_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "preferencesComplete",+ "columnName": "preferences_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "presetsComplete",+ "columnName": "presets_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "schedulesComplete",+ "columnName": "schedules_complete",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "preferenceSnapshotJson",+ "columnName": "preference_snapshot_json",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastError",+ "columnName": "last_error",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "restore_key"+ ]+ }+ },+ {+ "tableName": "provider_workflows",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `state` TEXT NOT NULL, `reason` TEXT NOT NULL, `priority` INTEGER NOT NULL, `force` INTEGER NOT NULL, `current_phase` TEXT, `lease_token` TEXT, `lease_expires_at` INTEGER, `heartbeat_at` INTEGER, `progress_message` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "reason",+ "columnName": "reason",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "priority",+ "columnName": "priority",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "force",+ "columnName": "force",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "currentPhase",+ "columnName": "current_phase",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseToken",+ "columnName": "lease_token",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "leaseExpiresAt",+ "columnName": "lease_expires_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "heartbeatAt",+ "columnName": "heartbeat_at",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "progressMessage",+ "columnName": "progress_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflows_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflows_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ },+ {+ "name": "index_provider_workflows_lease_expires_at",+ "unique": false,+ "columnNames": [+ "lease_expires_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflows_lease_expires_at` ON `${TABLE_NAME}` (`lease_expires_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "provider_workflow_phases",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `generation` INTEGER NOT NULL, `phase` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `checkpoint` TEXT, `last_error_code` TEXT, `last_error_message` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`provider_id`, `generation`, `phase`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "generation",+ "columnName": "generation",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "phase",+ "columnName": "phase",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "state",+ "columnName": "state",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "attemptCount",+ "columnName": "attempt_count",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "checkpoint",+ "columnName": "checkpoint",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorCode",+ "columnName": "last_error_code",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "lastErrorMessage",+ "columnName": "last_error_message",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "createdAt",+ "columnName": "created_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "completedAt",+ "columnName": "completed_at",+ "affinity": "INTEGER"+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "generation",+ "phase"+ ]+ },+ "indices": [+ {+ "name": "index_provider_workflow_phases_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ },+ {+ "name": "index_provider_workflow_phases_state",+ "unique": false,+ "columnNames": [+ "state"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_state` ON `${TABLE_NAME}` (`state`)"+ },+ {+ "name": "index_provider_workflow_phases_updated_at",+ "unique": false,+ "columnNames": [+ "updated_at"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_provider_workflow_phases_updated_at` ON `${TABLE_NAME}` (`updated_at`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_classification_overrides",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `source_key` TEXT NOT NULL, `stream_id` INTEGER NOT NULL, `target_type` TEXT NOT NULL, `group_key` TEXT NOT NULL, `series_key` TEXT, `series_name` TEXT, `season_number` INTEGER, `episode_number` INTEGER, `episode_title` TEXT, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `source_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "sourceKey",+ "columnName": "source_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "streamId",+ "columnName": "stream_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "seriesKey",+ "columnName": "series_key",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seriesName",+ "columnName": "series_name",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "seasonNumber",+ "columnName": "season_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeNumber",+ "columnName": "episode_number",+ "affinity": "INTEGER"+ },+ {+ "fieldPath": "episodeTitle",+ "columnName": "episode_title",+ "affinity": "TEXT"+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "source_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_classification_overrides_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_classification_overrides_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ },+ {+ "tableName": "m3u_category_classification_rules",+ "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`provider_id` INTEGER NOT NULL, `group_key` TEXT NOT NULL, `target_type` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`provider_id`, `group_key`), FOREIGN KEY(`provider_id`) REFERENCES `providers`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",+ "fields": [+ {+ "fieldPath": "providerId",+ "columnName": "provider_id",+ "affinity": "INTEGER",+ "notNull": true+ },+ {+ "fieldPath": "groupKey",+ "columnName": "group_key",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "targetType",+ "columnName": "target_type",+ "affinity": "TEXT",+ "notNull": true+ },+ {+ "fieldPath": "updatedAt",+ "columnName": "updated_at",+ "affinity": "INTEGER",+ "notNull": true+ }+ ],+ "primaryKey": {+ "autoGenerate": false,+ "columnNames": [+ "provider_id",+ "group_key"+ ]+ },+ "indices": [+ {+ "name": "index_m3u_category_classification_rules_provider_id",+ "unique": false,+ "columnNames": [+ "provider_id"+ ],+ "orders": [],+ "createSql": "CREATE INDEX IF NOT EXISTS `index_m3u_category_classification_rules_provider_id` ON `${TABLE_NAME}` (`provider_id`)"+ }+ ],+ "foreignKeys": [+ {+ "table": "providers",+ "onDelete": "CASCADE",+ "onUpdate": "NO ACTION",+ "columns": [+ "provider_id"+ ],+ "referencedColumns": [+ "id"+ ]+ }+ ]+ }+ ],+ "setupQueries": [+ "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",+ "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'f07479b71082d5112b7a7ea89a69720d')"+ ]+ }+}\ No newline at end of filediff --git a/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV75To76.kt b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV75To76.ktnew file mode 100644index 00000000..9b2bfa49--- /dev/null+++ b/data/src/main/java/com/streamvault/data/local/FeatureMigrationsV75To76.kt@@ -0,0 +1,50 @@+package com.streamvault.data.local++import androidx.room.migration.Migration+import androidx.sqlite.db.SupportSQLiteDatabase++object FeatureMigrationsV75To76 {+ val MIGRATION_75_76 = object : Migration(75, 76) {+ override fun migrate(database: SupportSQLiteDatabase) {+ database.execSQL(+ """+ CREATE TABLE IF NOT EXISTS m3u_classification_overrides (+ provider_id INTEGER NOT NULL,+ source_key TEXT NOT NULL,+ stream_id INTEGER NOT NULL,+ target_type TEXT NOT NULL,+ group_key TEXT NOT NULL,+ series_key TEXT,+ series_name TEXT,+ season_number INTEGER,+ episode_number INTEGER,+ episode_title TEXT,+ updated_at INTEGER NOT NULL,+ PRIMARY KEY(provider_id, source_key),+ FOREIGN KEY(provider_id) REFERENCES providers(id) ON DELETE CASCADE+ )+ """.trimIndent()+ )+ database.execSQL(+ "CREATE INDEX IF NOT EXISTS index_m3u_classification_overrides_provider_id " ++ "ON m3u_classification_overrides(provider_id)"+ )+ database.execSQL(+ """+ CREATE TABLE IF NOT EXISTS m3u_category_classification_rules (+ provider_id INTEGER NOT NULL,+ group_key TEXT NOT NULL,+ target_type TEXT NOT NULL,+ updated_at INTEGER NOT NULL,+ PRIMARY KEY(provider_id, group_key),+ FOREIGN KEY(provider_id) REFERENCES providers(id) ON DELETE CASCADE+ )+ """.trimIndent()+ )+ database.execSQL(+ "CREATE INDEX IF NOT EXISTS index_m3u_category_classification_rules_provider_id " ++ "ON m3u_category_classification_rules(provider_id)"+ )+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.ktindex 8b1d83ca..8611f7af 100644--- a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt+++ b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt@@ -12,7 +12,7 @@ import org.json.JSONObjectimport java.net.URIimport java.security.MessageDigest-internal const val STREAM_VAULT_DATABASE_VERSION = 75+internal const val STREAM_VAULT_DATABASE_VERSION = 76@Database(entities = [@@ -68,7 +68,9 @@ internal const val STREAM_VAULT_DATABASE_VERSION = 75ProviderConfigRevisionEntity::class,BackupRestoreCheckpointEntity::class,ProviderWorkflowEntity::class,- ProviderWorkflowPhaseEntity::class+ ProviderWorkflowPhaseEntity::class,+ M3uClassificationOverrideEntity::class,+ M3uCategoryClassificationRuleEntity::class],version = STREAM_VAULT_DATABASE_VERSION,exportSchema = true // ← was false; schema JSON now tracked in version control@@ -121,6 +123,7 @@ abstract class StreamVaultDatabase : RoomDatabase() {abstract fun providerConfigRevisionDao(): ProviderConfigRevisionDaoabstract fun backupRestoreCheckpointDao(): BackupRestoreCheckpointDaoabstract fun providerWorkflowDao(): ProviderWorkflowDao+ abstract fun m3uClassificationDao(): M3uClassificationDaocompanion object {val MIGRATION_1_2 = LegacyMigrationsV1To24.MIGRATION_1_2@@ -197,5 +200,6 @@ abstract class StreamVaultDatabase : RoomDatabase() {val MIGRATION_72_73 = FeatureMigrationsV49To75.MIGRATION_72_73val MIGRATION_73_74 = FeatureMigrationsV49To75.MIGRATION_73_74val MIGRATION_74_75 = FeatureMigrationsV49To75.MIGRATION_74_75+ val MIGRATION_75_76 = FeatureMigrationsV75To76.MIGRATION_75_76}}diff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.ktindex b1da6e5d..062facc9 100644--- a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt+++ b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt@@ -12,7 +12,8 @@ object StreamVaultDatabaseMigrationRegistry {val v1To24: List<Migration> = LegacyMigrationsV1To24.allval v24To49: List<Migration> = LegacyMigrationsV24To49.allval v49To75: List<Migration> = FeatureMigrationsV49To75.all- val all: List<Migration> = (v1To24 + v24To49 + v49To75).also(::validate)+ val v75To76: List<Migration> = listOf(FeatureMigrationsV75To76.MIGRATION_75_76)+ val all: List<Migration> = (v1To24 + v24To49 + v49To75 + v75To76).also(::validate)private fun validate(migrations: List<Migration>) {require(migrations.map { it.startVersion }.distinct().size == migrations.size) {diff --git a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt b/data/src/main/java/com/streamvault/data/local/dao/Daos.ktindex 6bc9a255..17c03dfa 100644--- a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt+++ b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt@@ -431,6 +431,9 @@ abstract class ChannelDao {@Query("SELECT * FROM channels WHERE id = :id")abstract suspend fun getById(id: Long): ChannelEntity?+ @Insert(onConflict = OnConflictStrategy.REPLACE)+ abstract suspend fun insert(channel: ChannelEntity): Long+@Query("SELECT * FROM channels WHERE provider_id = :providerId AND stream_id = :streamId LIMIT 1")abstract suspend fun getByStreamId(providerId: Long, streamId: Long): ChannelEntity?@@ -475,6 +478,9 @@ abstract class ChannelDao {@Query("SELECT * FROM channels WHERE provider_id = :providerId")abstract suspend fun getByProviderSync(providerId: Long): List<ChannelEntity>+ @Query("SELECT * FROM channels WHERE provider_id = :providerId AND category_id = :categoryId")+ abstract suspend fun getByCategorySync(providerId: Long, categoryId: Long): List<ChannelEntity>+@Insert(onConflict = OnConflictStrategy.REPLACE)abstract suspend fun insertAll(channels: List<ChannelEntity>)@@ -493,6 +499,9 @@ abstract class ChannelDao {@Query("DELETE FROM channels WHERE id IN (:ids)")abstract suspend fun deleteByIds(ids: List<Long>)+ @Query("DELETE FROM channels WHERE id = :id")+ abstract suspend fun deleteById(id: Long)+@Transactionopen suspend fun replaceAll(providerId: Long, channels: List<ChannelEntity>) {val existingByRemoteId = getIdMappings(providerId).associate { it.remoteId to it.id }@@ -1619,6 +1628,9 @@ interface MovieDao {@Query("SELECT * FROM movies WHERE id = :id")suspend fun getById(id: Long): MovieEntity?+ @Insert(onConflict = OnConflictStrategy.REPLACE)+ suspend fun insert(movie: MovieEntity): Long+@Query("SELECT * FROM movies WHERE provider_id = :providerId")suspend fun getByProviderSync(providerId: Long): List<MovieEntity>@@ -1753,6 +1765,9 @@ interface MovieDao {@Query("DELETE FROM movies WHERE id IN (:ids)")suspend fun deleteByIds(ids: List<Long>)+ @Query("DELETE FROM movies WHERE id = :id")+ suspend fun deleteById(id: Long)+@Query("DELETE FROM movies WHERE provider_id = :providerId AND category_id = :categoryId AND stream_id NOT IN (:remoteIds)")suspend fun deleteMissingByCategory(providerId: Long, categoryId: Long, remoteIds: List<Long>)@@ -2626,6 +2641,9 @@ interface SeriesDao {@Query("SELECT * FROM series WHERE id = :id")suspend fun getById(id: Long): SeriesEntity?+ @Insert(onConflict = OnConflictStrategy.REPLACE)+ suspend fun insert(series: SeriesEntity): Long+@Query("SELECT * FROM series WHERE provider_id = :providerId")suspend fun getByProviderSync(providerId: Long): List<SeriesEntity>@@ -2703,6 +2721,9 @@ interface SeriesDao {@Query("DELETE FROM series WHERE id IN (:ids)")suspend fun deleteByIds(ids: List<Long>)+ @Query("DELETE FROM series WHERE id = :id")+ suspend fun deleteById(id: Long)+@Transactionsuspend fun replaceAll(providerId: Long, series: List<SeriesEntity>) {val existingByRemoteId = getIdMappings(providerId).associate { it.remoteId to it.id }@@ -2812,9 +2833,18 @@ interface EpisodeDao {@Query("SELECT * FROM episodes WHERE series_id = :seriesId ORDER BY season_number ASC, episode_number ASC")suspend fun getBySeriesSync(seriesId: Long): List<EpisodeBrowseEntity>+ @Query("SELECT * FROM episodes WHERE series_id = :seriesId ORDER BY season_number ASC, episode_number ASC")+ suspend fun getEntitiesBySeriesSync(seriesId: Long): List<EpisodeEntity>+@Query("SELECT * FROM episodes WHERE id = :id")suspend fun getById(id: Long): EpisodeEntity?+ @Query("SELECT * FROM episodes WHERE provider_id = :providerId AND episode_id = :episodeId LIMIT 1")+ suspend fun getByProviderAndEpisodeId(providerId: Long, episodeId: Long): EpisodeEntity?++ @Insert(onConflict = OnConflictStrategy.REPLACE)+ suspend fun insert(episode: EpisodeEntity): Long+@Query("SELECT * FROM episodes WHERE provider_id = :providerId AND series_id = :seriesId AND episode_id = :episodeId LIMIT 1")@@ -2912,6 +2942,9 @@ interface EpisodeDao {@Query("DELETE FROM episodes WHERE series_id = :seriesId")suspend fun deleteBySeries(seriesId: Long)+ @Query("DELETE FROM episodes WHERE id = :id")+ suspend fun deleteById(id: Long)+@Query("DELETE FROM episodes WHERE series_id NOT IN (SELECT id FROM series)")suspend fun deleteOrphans(): Int@@ -3334,9 +3367,25 @@ abstract class FavoriteDao {@Query("DELETE FROM favorites WHERE provider_id = :providerId AND content_id = :contentId AND content_type = :contentType AND (:groupId IS NULL AND group_id IS NULL OR group_id = :groupId)")abstract suspend fun delete(providerId: Long, contentId: Long, contentType: String, groupId: Long?)+ @Query("DELETE FROM favorites WHERE provider_id = :providerId AND content_id = :contentId AND content_type = :contentType")+ abstract suspend fun deleteByContent(providerId: Long, contentId: Long, contentType: String)+@Query("DELETE FROM favorites WHERE provider_id = :providerId AND content_type = :contentType")abstract suspend fun deleteByProviderAndType(providerId: Long, contentType: String)+ @Query(+ "UPDATE favorites SET content_id = :newContentId, content_type = :newContentType, " ++ "group_id = NULL, group_key = 0 WHERE provider_id = :providerId " ++ "AND content_id = :oldContentId AND content_type = :oldContentType"+ )+ abstract suspend fun migrateContent(+ providerId: Long,+ oldContentId: Long,+ oldContentType: String,+ newContentId: Long,+ newContentType: String+ )+@Query("DELETE FROM favorites WHERE content_type = 'LIVE' AND content_id NOT IN (SELECT id FROM channels)")abstract suspend fun deleteMissingLiveFavorites(): Int@@ -3517,6 +3566,22 @@ interface PlaybackHistoryDao {@Query("DELETE FROM playback_history WHERE content_id = :contentId AND content_type = :contentType AND provider_id = :providerId")suspend fun delete(contentId: Long, contentType: String, providerId: Long)+ @Query(+ "UPDATE playback_history SET content_id = :newContentId, content_type = :newContentType, " ++ "series_id = :newSeriesId, season_number = :seasonNumber, episode_number = :episodeNumber " ++ "WHERE content_id = :oldContentId AND content_type = :oldContentType AND provider_id = :providerId"+ )+ suspend fun migrateContent(+ oldContentId: Long,+ oldContentType: String,+ newContentId: Long,+ newContentType: String,+ providerId: Long,+ newSeriesId: Long? = null,+ seasonNumber: Int? = null,+ episodeNumber: Int? = null+ )+@Query("DELETE FROM playback_history")suspend fun deleteAll()diff --git a/data/src/main/java/com/streamvault/data/local/dao/M3uClassificationDao.kt b/data/src/main/java/com/streamvault/data/local/dao/M3uClassificationDao.ktnew file mode 100644index 00000000..e5058891--- /dev/null+++ b/data/src/main/java/com/streamvault/data/local/dao/M3uClassificationDao.kt@@ -0,0 +1,38 @@+package com.streamvault.data.local.dao++import androidx.room.Dao+import androidx.room.Insert+import androidx.room.OnConflictStrategy+import androidx.room.Query+import com.streamvault.data.local.entity.M3uCategoryClassificationRuleEntity+import com.streamvault.data.local.entity.M3uClassificationOverrideEntity++@Dao+interface M3uClassificationDao {+ @Query("SELECT * FROM m3u_classification_overrides WHERE provider_id = :providerId")+ suspend fun getOverrides(providerId: Long): List<M3uClassificationOverrideEntity>++ @Query("SELECT * FROM m3u_category_classification_rules WHERE provider_id = :providerId")+ suspend fun getCategoryRules(providerId: Long): List<M3uCategoryClassificationRuleEntity>++ @Query("SELECT * FROM m3u_classification_overrides WHERE provider_id = :providerId AND source_key = :sourceKey LIMIT 1")+ suspend fun getOverride(providerId: Long, sourceKey: String): M3uClassificationOverrideEntity?++ @Query("SELECT * FROM m3u_classification_overrides WHERE provider_id = :providerId AND stream_id = :streamId LIMIT 1")+ suspend fun getByStreamId(providerId: Long, streamId: Long): M3uClassificationOverrideEntity?++ @Insert(onConflict = OnConflictStrategy.REPLACE)+ suspend fun upsertOverride(override: M3uClassificationOverrideEntity)++ @Insert(onConflict = OnConflictStrategy.REPLACE)+ suspend fun upsertOverrides(overrides: List<M3uClassificationOverrideEntity>)++ @Insert(onConflict = OnConflictStrategy.REPLACE)+ suspend fun upsertCategoryRule(rule: M3uCategoryClassificationRuleEntity)++ @Query("DELETE FROM m3u_classification_overrides WHERE provider_id = :providerId AND source_key = :sourceKey")+ suspend fun deleteOverride(providerId: Long, sourceKey: String)++ @Query("DELETE FROM m3u_category_classification_rules WHERE provider_id = :providerId AND group_key = :groupKey")+ suspend fun deleteCategoryRule(providerId: Long, groupKey: String)+}diff --git a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt b/data/src/main/java/com/streamvault/data/local/entity/Entities.ktindex c1083c89..b4f2370a 100644--- a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt+++ b/data/src/main/java/com/streamvault/data/local/entity/Entities.kt@@ -31,6 +31,49 @@ import com.streamvault.domain.model.StalkerProtocolPreferenceimport com.streamvault.domain.model.StalkerTransportModeimport com.streamvault.domain.model.XmltvTimezonePolicy+@Entity(+ tableName = "m3u_classification_overrides",+ primaryKeys = ["provider_id", "source_key"],+ foreignKeys = [ForeignKey(+ entity = ProviderEntity::class,+ parentColumns = ["id"],+ childColumns = ["provider_id"],+ onDelete = ForeignKey.CASCADE+ )],+ indices = [Index(value = ["provider_id"])]+)+data class M3uClassificationOverrideEntity(+ @ColumnInfo(name = "provider_id") val providerId: Long,+ @ColumnInfo(name = "source_key") val sourceKey: String,+ @ColumnInfo(name = "stream_id") val streamId: Long,+ @ColumnInfo(name = "target_type") val targetType: String,+ @ColumnInfo(name = "group_key") val groupKey: String = "",+ @ColumnInfo(name = "series_key") val seriesKey: String? = null,+ @ColumnInfo(name = "series_name") val seriesName: String? = null,+ @ColumnInfo(name = "season_number") val seasonNumber: Int? = null,+ @ColumnInfo(name = "episode_number") val episodeNumber: Int? = null,+ @ColumnInfo(name = "episode_title") val episodeTitle: String? = null,+ @ColumnInfo(name = "updated_at") val updatedAt: Long = System.currentTimeMillis()+)++@Entity(+ tableName = "m3u_category_classification_rules",+ primaryKeys = ["provider_id", "group_key"],+ foreignKeys = [ForeignKey(+ entity = ProviderEntity::class,+ parentColumns = ["id"],+ childColumns = ["provider_id"],+ onDelete = ForeignKey.CASCADE+ )],+ indices = [Index(value = ["provider_id"])]+)+data class M3uCategoryClassificationRuleEntity(+ @ColumnInfo(name = "provider_id") val providerId: Long,+ @ColumnInfo(name = "group_key") val groupKey: String,+ @ColumnInfo(name = "target_type") val targetType: String,+ @ColumnInfo(name = "updated_at") val updatedAt: Long = System.currentTimeMillis()+)+@Entity(tableName = "providers",indices = [Index(value = ["type"]), Index(value = ["is_active"])]diff --git a/data/src/main/java/com/streamvault/data/parser/M3uSourceIdentity.kt b/data/src/main/java/com/streamvault/data/parser/M3uSourceIdentity.ktnew file mode 100644index 00000000..5c7e6521--- /dev/null+++ b/data/src/main/java/com/streamvault/data/parser/M3uSourceIdentity.kt@@ -0,0 +1,68 @@+package com.streamvault.data.parser++import com.streamvault.data.local.entity.ChannelEntity+import com.streamvault.data.local.entity.MovieEntity+import java.net.URI+import java.security.MessageDigest+import java.util.Locale++/** Stable, destination-independent identity for an M3U entry. */+internal object M3uSourceIdentity {+ fun fromEntry(providerId: Long, entry: M3uParser.M3uEntry): String =+ hash(providerId, entry.tvgId ?: entry.tvgName, entry.url, entry.name)++ fun stableLongId(providerId: Long, entry: M3uParser.M3uEntry): Long =+ stableLong(providerId, entry.tvgId ?: entry.tvgName, entry.url, entry.name)++ fun fromChannel(channel: ChannelEntity): String =+ hash(channel.providerId, channel.epgChannelId, channel.streamUrl, channel.name)++ fun fromMovie(movie: MovieEntity): String =+ hash(movie.providerId, null, movie.streamUrl, movie.name)++ fun groupKey(groupTitle: String?): String = normalize(groupTitle.orEmpty())++ private fun hash(providerId: Long, externalId: String?, url: String, title: String): String {+ val identity = identity(providerId, externalId, url, title)+ val digest = MessageDigest.getInstance("SHA-256").digest(identity.toByteArray(Charsets.UTF_8))+ return digest.joinToString("") { byte -> "%02x".format(Locale.ROOT, byte) }+ }++ private fun stableLong(providerId: Long, externalId: String?, url: String, title: String): Long {+ val digest = MessageDigest.getInstance("SHA-256")+ .digest(identity(providerId, externalId, url, title).toByteArray(Charsets.UTF_8))+ var result = 0L+ repeat(8) { index -> result = (result shl 8) or (digest[index].toLong() and 0xff) }+ return (result and Long.MAX_VALUE).coerceAtLeast(1L)+ }++ private fun identity(providerId: Long, externalId: String?, url: String, title: String): String {+ val normalizedExternalId = externalId?.trim()?.lowercase(Locale.ROOT).orEmpty()+ return if (normalizedExternalId.isNotBlank()) {+ // tvg-id/tvg-name is the provider's durable identity when supplied. Titles and+ // signed URL query parameters commonly change during a playlist refresh.+ "$providerId|external=$normalizedExternalId"+ } else {+ "$providerId|url=${canonicalUrl(url)}|title=${normalize(title)}"+ }+ }++ private fun canonicalUrl(url: String): String = runCatching {+ val parsed = URI(url)+ buildString {+ append(parsed.scheme?.lowercase(Locale.ROOT).orEmpty())+ append("://")+ append(parsed.host?.lowercase(Locale.ROOT).orEmpty())+ parsed.port.takeIf { it > 0 }?.let { append(':').append(it) }+ append(parsed.rawPath.orEmpty())+ // Query parameters are intentionally retained. M3U URLs frequently use the+ // query as a credential or token, so this identity is never shown to users.+ parsed.rawQuery?.let { append('?').append(it) }+ }+ }.getOrElse { url.substringBefore('#') }++ private fun normalize(value: String): String = value+ .trim()+ .lowercase(Locale.ROOT)+ .replace(Regex("\\s+"), " ")+}diff --git a/data/src/main/java/com/streamvault/data/repository/M3uClassificationRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/M3uClassificationRepositoryImpl.ktnew file mode 100644index 00000000..f767594b--- /dev/null+++ b/data/src/main/java/com/streamvault/data/repository/M3uClassificationRepositoryImpl.kt@@ -0,0 +1,541 @@+package com.streamvault.data.repository++import com.streamvault.data.local.DatabaseTransactionRunner+import com.streamvault.data.local.dao.CategoryDao+import com.streamvault.data.local.dao.ChannelDao+import com.streamvault.data.local.dao.EpisodeDao+import com.streamvault.data.local.dao.FavoriteDao+import com.streamvault.data.local.dao.M3uClassificationDao+import com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.PlaybackHistoryDao+import com.streamvault.data.local.dao.ProviderDao+import com.streamvault.data.local.dao.SeriesDao+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.ChannelEntity+import com.streamvault.data.local.entity.EpisodeEntity+import com.streamvault.data.local.entity.M3uCategoryClassificationRuleEntity+import com.streamvault.data.local.entity.M3uClassificationOverrideEntity+import com.streamvault.data.local.entity.MovieEntity+import com.streamvault.data.local.entity.SeriesEntity+import com.streamvault.data.parser.M3uSourceIdentity+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SeriesCatalogOrigin+import com.streamvault.domain.repository.M3uClassificationRepository+import com.streamvault.domain.repository.M3uCategoryItem+import com.streamvault.domain.repository.M3uClassificationTarget+import com.streamvault.domain.repository.M3uSeriesAssignment+import java.security.MessageDigest+import java.util.Locale+import javax.inject.Inject+import javax.inject.Singleton++@Singleton+class M3uClassificationRepositoryImpl @Inject constructor(+ private val providerDao: ProviderDao,+ private val channelDao: ChannelDao,+ private val movieDao: MovieDao,+ private val seriesDao: SeriesDao,+ private val episodeDao: EpisodeDao,+ private val favoriteDao: FavoriteDao,+ private val playbackHistoryDao: PlaybackHistoryDao,+ private val categoryDao: CategoryDao,+ private val classificationDao: M3uClassificationDao,+ private val transactionRunner: DatabaseTransactionRunner+) : M3uClassificationRepository {++ override suspend fun getCategoryItems(+ providerId: Long,+ categoryId: Long+ ): Result<List<M3uCategoryItem>> = runOperation(providerId) {+ val categoryExists = categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name)+ .any { it.categoryId == categoryId }+ require(categoryExists) { "Category no longer exists" }+ channelDao.getByCategorySync(providerId, categoryId).map { channel ->+ M3uCategoryItem(+ channelId = channel.id,+ title = channel.name,+ suggestedAssignment = inferSeriesAssignment(channel.name)+ ?: M3uSeriesAssignment(+ seriesName = cleanSeriesName(channel.name),+ episodeNumber = 0,+ episodeTitle = channel.name+ )+ )+ }+ }++ override suspend fun classifyChannel(+ providerId: Long,+ channelId: Long,+ target: M3uClassificationTarget,+ series: M3uSeriesAssignment?+ ): Result<Unit> = runOperation(providerId) {+ val channel = channelDao.getById(channelId)+ ?: throw IllegalArgumentException("Channel no longer exists")+ classifyChannelInternal(providerId, channel, target, series)+ }++ override suspend fun classifyChannelByStream(+ providerId: Long,+ streamId: Long,+ target: M3uClassificationTarget,+ series: M3uSeriesAssignment?+ ): Result<Unit> = runOperation(providerId) {+ val channel = channelDao.getByStreamId(providerId, streamId)+ ?: throw IllegalArgumentException("Channel no longer exists")+ classifyChannelInternal(providerId, channel, target, series)+ }++ private suspend fun classifyChannelInternal(+ providerId: Long,+ channel: ChannelEntity,+ target: M3uClassificationTarget,+ series: M3uSeriesAssignment?+ ) {+ val sourceKey = M3uSourceIdentity.fromChannel(channel)+ val groupKey = M3uSourceIdentity.groupKey(channel.groupTitle)+ when (target) {+ M3uClassificationTarget.LIVE -> {+ classificationDao.upsertOverride(+ overrideEntity(+ providerId = providerId,+ sourceKey = sourceKey,+ streamId = channel.streamId,+ target = target,+ groupKey = groupKey+ )+ )+ }+ M3uClassificationTarget.MOVIE -> {+ val movieId = upsertMovie(channel)+ migrateHistory(channel.id, ContentType.LIVE, movieId, ContentType.MOVIE, channel)+ classificationDao.upsertOverride(+ overrideEntity(providerId, sourceKey, channel.streamId, target, groupKey)+ )+ channelDao.deleteById(channel.id)+ }+ M3uClassificationTarget.SERIES -> {+ val assignment = series ?: inferSeriesAssignment(channel.name)+ ?: M3uSeriesAssignment(+ seriesName = cleanSeriesName(channel.name),+ episodeNumber = 0,+ episodeTitle = channel.name+ )+ val localSeriesId = upsertSeries(channel, assignment)+ val episodeId = upsertEpisode(channel, localSeriesId, assignment)+ migrateHistory(+ oldContentId = channel.id,+ oldType = ContentType.LIVE,+ newContentId = episodeId,+ newType = ContentType.SERIES_EPISODE,+ channel = channel,+ newSeriesId = localSeriesId,+ seasonNumber = assignment.seasonNumber,+ episodeNumber = assignment.episodeNumber+ )+ classificationDao.upsertOverride(+ overrideEntity(+ providerId = providerId,+ sourceKey = sourceKey,+ streamId = channel.streamId,+ target = target,+ groupKey = groupKey,+ series = assignment+ )+ )+ channelDao.deleteById(channel.id)+ }+ }+ }++ override suspend fun classifyCategory(+ providerId: Long,+ categoryId: Long,+ target: M3uClassificationTarget,+ seriesAssignments: Map<Long, M3uSeriesAssignment>+ ): Result<Int> = try {+ ensureM3uProvider(providerId)+ val category = categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name)+ .firstOrNull { it.categoryId == categoryId }+ ?: throw IllegalArgumentException("Category no longer exists")+ val groupKey = M3uSourceIdentity.groupKey(category.name)+ transactionRunner.inTransaction {+ classificationDao.upsertCategoryRule(+ M3uCategoryClassificationRuleEntity(+ providerId = providerId,+ groupKey = groupKey,+ targetType = target.name+ )+ )+ val channels = channelDao.getByCategorySync(providerId, categoryId)+ channels.forEach { channel ->+ if (target == M3uClassificationTarget.SERIES) {+ classifyChannelInternal(providerId, channel, target, seriesAssignments[channel.id])+ } else {+ val sourceKey = M3uSourceIdentity.fromChannel(channel)+ classificationDao.upsertOverride(+ overrideEntity(providerId, sourceKey, channel.streamId, target, groupKey)+ )+ if (target == M3uClassificationTarget.MOVIE) {+ val movieId = upsertMovie(channel)+ migrateHistory(channel.id, ContentType.LIVE, movieId, ContentType.MOVIE, channel)+ channelDao.deleteById(channel.id)+ }+ }+ }+ var restoredCount = 0+ if (target == M3uClassificationTarget.LIVE) {+ val orphanSeriesIds = mutableSetOf<Long>()+ classificationDao.getOverrides(providerId)+ .filter { it.groupKey == groupKey && it.targetType != M3uClassificationTarget.LIVE.name }+ .forEach { override ->+ when (override.targetType) {+ M3uClassificationTarget.MOVIE.name -> {+ movieDao.getByStreamId(providerId, override.streamId)?.let { movie ->+ restoreMovieToLive(providerId, movie)+ restoredCount+++ }+ }+ M3uClassificationTarget.SERIES.name -> {+ episodeDao.getByProviderAndEpisodeId(providerId, override.streamId)?.let { episode ->+ orphanSeriesIds += restoreEpisodeToLive(providerId, episode)+ restoredCount+++ }+ }+ }+ }+ orphanSeriesIds.forEach { seriesId ->+ if (episodeDao.getEntitiesBySeriesSync(seriesId).isEmpty()) {+ seriesDao.deleteById(seriesId)+ }+ }+ }+ channels.size + restoredCount+ }.let { count -> Result.success(count) }+ } catch (error: Exception) {+ Result.error("Unable to classify M3U category", error)+ }++ override suspend fun moveMovieBackToLive(providerId: Long, movieId: Long): Result<Unit> =+ runOperation(providerId) {+ val movie = movieDao.getById(movieId)+ ?: throw IllegalArgumentException("Movie no longer exists")+ restoreMovieToLive(providerId, movie)+ }++ override suspend fun moveEpisodeBackToLive(providerId: Long, episodeId: Long): Result<Unit> =+ runOperation(providerId) {+ val episode = episodeDao.getById(episodeId)+ ?: throw IllegalArgumentException("Episode no longer exists")+ val seriesId = restoreEpisodeToLive(providerId, episode)+ if (episodeDao.getEntitiesBySeriesSync(seriesId).isEmpty()) {+ seriesDao.deleteById(seriesId)+ }+ }++ override suspend fun moveSeriesBackToLive(providerId: Long, seriesId: Long): Result<Unit> =+ runOperation(providerId) {+ val series = seriesDao.getById(seriesId)+ ?: throw IllegalArgumentException("Series no longer exists")+ episodeDao.getEntitiesBySeriesSync(series.id).forEach { episode ->+ restoreEpisodeToLive(providerId, episode)+ }+ seriesDao.deleteById(series.id)+ }++ private suspend fun restoreMovieToLive(providerId: Long, movie: MovieEntity) {+ val override = classificationDao.getByStreamId(providerId, movie.streamId)+ val liveDestination = liveDestination(providerId, override?.groupKey)+ val channel = ChannelEntity(+ streamId = movie.streamId,+ name = movie.name,+ logoUrl = movie.posterUrl,+ groupTitle = liveDestination.name,+ categoryId = liveDestination.id,+ categoryName = liveDestination.name,+ streamUrl = movie.streamUrl,+ providerId = providerId,+ isAdult = movie.isAdult+ )+ val newChannelId = channelDao.insert(channel)+ migrateHistory(movie.id, ContentType.MOVIE, newChannelId, ContentType.LIVE, channel)+ classificationDao.upsertOverride(+ (override ?: M3uClassificationOverrideEntity(+ providerId = providerId,+ sourceKey = M3uSourceIdentity.fromMovie(movie),+ streamId = movie.streamId,+ targetType = M3uClassificationTarget.LIVE.name,+ groupKey = M3uSourceIdentity.groupKey(movie.categoryName)+ )).copy(targetType = M3uClassificationTarget.LIVE.name)+ )+ movieDao.deleteById(movie.id)+ }++ private suspend fun restoreEpisodeToLive(providerId: Long, episode: EpisodeEntity): Long {+ val series = seriesDao.getById(episode.seriesId)+ ?: throw IllegalArgumentException("Series no longer exists")+ val override = classificationDao.getByStreamId(providerId, episode.episodeId)+ val liveDestination = liveDestination(providerId, override?.groupKey)+ val channel = ChannelEntity(+ streamId = episode.episodeId,+ name = episode.title,+ logoUrl = episode.coverUrl,+ groupTitle = liveDestination.name,+ categoryId = liveDestination.id,+ categoryName = liveDestination.name,+ streamUrl = episode.streamUrl,+ providerId = providerId,+ isAdult = episode.isAdult+ )+ val newChannelId = channelDao.insert(channel)+ migrateHistory(+ episode.id,+ ContentType.SERIES_EPISODE,+ newChannelId,+ ContentType.LIVE,+ channel+ )+ classificationDao.upsertOverride(+ (override ?: M3uClassificationOverrideEntity(+ providerId = providerId,+ sourceKey = M3uSourceIdentity.fromChannel(channel),+ streamId = episode.episodeId,+ targetType = M3uClassificationTarget.LIVE.name,+ groupKey = M3uSourceIdentity.groupKey(series.categoryName)+ )).copy(targetType = M3uClassificationTarget.LIVE.name)+ )+ episodeDao.deleteById(episode.id)+ return series.id+ }++ private suspend fun upsertMovie(channel: ChannelEntity): Long {+ ensureCategory(channel.providerId, ContentType.MOVIE, "Movies")+ val existing = movieDao.getByStreamId(channel.providerId, channel.streamId)+ return movieDao.insert(+ MovieEntity(+ id = existing?.id ?: 0L,+ streamId = channel.streamId,+ name = channel.name,+ posterUrl = channel.logoUrl,+ categoryId = manualCategoryId(channel.providerId, ContentType.MOVIE),+ categoryName = "Movies",+ streamUrl = channel.streamUrl,+ providerId = channel.providerId,+ isAdult = channel.isAdult+ )+ )+ }++ private suspend fun upsertSeries(channel: ChannelEntity, assignment: M3uSeriesAssignment): Long {+ ensureCategory(channel.providerId, ContentType.SERIES, "Series")+ val seriesKey = seriesKey(channel.providerId, assignment.seriesName)+ val existing = seriesDao.getByProviderSeriesId(channel.providerId, seriesKey)+ return if (existing != null) {+ existing.id+ } else {+ seriesDao.insert(+ SeriesEntity(+ seriesId = hashToId(seriesKey),+ providerSeriesId = seriesKey,+ name = assignment.seriesName,+ posterUrl = channel.logoUrl,+ categoryId = manualCategoryId(channel.providerId, ContentType.SERIES),+ categoryName = "Series",+ providerId = channel.providerId,+ catalogOrigin = SeriesCatalogOrigin.VOD_DERIVED+ )+ )+ }+ }++ private suspend fun upsertEpisode(+ channel: ChannelEntity,+ localSeriesId: Long,+ assignment: M3uSeriesAssignment+ ): Long {+ val existing = episodeDao.getByProviderSeriesAndEpisodeId(+ channel.providerId,+ localSeriesId,+ channel.streamId+ )+ return episodeDao.insert(+ EpisodeEntity(+ id = existing?.id ?: 0L,+ episodeId = channel.streamId,+ title = assignment.episodeTitle?.takeIf(String::isNotBlank) ?: channel.name,+ episodeNumber = assignment.episodeNumber?.coerceAtLeast(0) ?: 0,+ seasonNumber = assignment.seasonNumber.coerceAtLeast(1),+ streamUrl = channel.streamUrl,+ coverUrl = channel.logoUrl,+ seriesId = localSeriesId,+ providerId = channel.providerId,+ isAdult = channel.isAdult+ )+ )+ }++ private suspend fun migrateHistory(+ oldContentId: Long,+ oldType: ContentType,+ newContentId: Long,+ newType: ContentType,+ channel: ChannelEntity,+ newSeriesId: Long? = null,+ seasonNumber: Int? = null,+ episodeNumber: Int? = null+ ) {+ playbackHistoryDao.delete(newContentId, newType.name, channel.providerId)+ favoriteDao.deleteByContent(channel.providerId, newContentId, newType.name)+ playbackHistoryDao.migrateContent(+ oldContentId = oldContentId,+ oldContentType = oldType.name,+ newContentId = newContentId,+ newContentType = newType.name,+ providerId = channel.providerId,+ newSeriesId = newSeriesId,+ seasonNumber = seasonNumber,+ episodeNumber = episodeNumber+ )+ favoriteDao.migrateContent(+ providerId = channel.providerId,+ oldContentId = oldContentId,+ oldContentType = oldType.name,+ newContentId = newContentId,+ newContentType = newType.name+ )+ }++ private suspend fun ensureM3uProvider(providerId: Long) {+ require(providerDao.getById(providerId)?.type == ProviderType.M3U) {+ "M3U classification is unavailable for this provider"+ }+ }++ private suspend fun <T> runOperation(providerId: Long, block: suspend () -> T): Result<T> = try {+ ensureM3uProvider(providerId)+ transactionRunner.inTransaction { block() }.let { value -> Result.success(value) }+ } catch (error: Exception) {+ Result.error("Unable to update M3U classification", error)+ }++ private suspend fun ensureCategory(providerId: Long, type: ContentType, name: String) {+ val exists = categoryDao.getByProviderAndTypeSync(providerId, type.name)+ .any { it.categoryId == manualCategoryId(providerId, type) }+ if (!exists) {+ categoryDao.insertAll(+ listOf(+ CategoryEntity(+ categoryId = manualCategoryId(providerId, type),+ name = name,+ type = type,+ providerId = providerId,+ syncFingerprint = "m3u-manual-${type.name.lowercase(Locale.ROOT)}"+ )+ )+ )+ }+ }++ private fun overrideEntity(+ providerId: Long,+ sourceKey: String,+ streamId: Long,+ target: M3uClassificationTarget,+ groupKey: String,+ series: M3uSeriesAssignment? = null+ ) = M3uClassificationOverrideEntity(+ providerId = providerId,+ sourceKey = sourceKey,+ streamId = streamId,+ targetType = target.name,+ groupKey = groupKey,+ seriesKey = series?.let { seriesKey(providerId, it.seriesName) },+ seriesName = series?.seriesName,+ seasonNumber = series?.seasonNumber,+ episodeNumber = series?.episodeNumber,+ episodeTitle = series?.episodeTitle+ )++ private fun cleanSeriesName(title: String): String = title+ .replace(Regex("(?i)\\b(?:s\\d+e\\d+|\\d+x\\d+|season\\s+\\d+\\s+episode\\s+\\d+|phần\\s+\\d+\\s*-\\s*tập\\s+\\d+)\\b"), "")+ .replace(Regex("(?i)\\b(?:episode|ep|tập)\\s+(?:cuối|\\d+)\\b"), "")+ .replace(Regex("\\s{2,}"), " ")+ .trim()+ .ifBlank { title.trim() }++ private fun inferSeriesAssignment(title: String): M3uSeriesAssignment? {+ val patterns = listOf(+ Regex("(?i)^(.*?)[\\s._-]*s(\\d{1,2})[\\s._-]*e(\\d{1,3}).*$"),+ Regex("(?i)^(.*?)[\\s._-]*(\\d{1,2})x(\\d{1,3}).*$"),+ Regex("(?i)^(.*?)\\s+season\\s+(\\d{1,2})\\s+episode\\s+(\\d{1,3}).*$"),+ Regex("(?i)^(.*?)\\s+phần\\s+(\\d{1,2})\\s*-\\s*tập\\s+(\\d{1,3}).*$"),+ Regex("(?i)^(.*?)[\\s._-]*(?:episode|ep|tập)\\s+(\\d{1,3}).*$")+ )+ patterns.forEach { pattern ->+ val match = pattern.matchEntire(title.trim()) ?: return@forEach+ val groups = match.groupValues+ val hasSeason = groups.size >= 4 && groups[2].toIntOrNull() != null && groups[3].toIntOrNull() != null+ val season = if (hasSeason) groups[2].toInt() else 1+ val episode = if (hasSeason) groups[3].toIntOrNull() else groups.getOrNull(2)?.toIntOrNull()+ if (episode != null) {+ return M3uSeriesAssignment(+ seriesName = cleanSeriesName(groups[1]),+ seasonNumber = season.coerceAtLeast(1),+ episodeNumber = episode.coerceAtLeast(1),+ episodeTitle = title.trim()+ )+ }+ }+ // Keep the item in the series projection, but mark its episode number as unresolved+ // rather than inventing E1. The original title is retained for manual correction.+ return M3uSeriesAssignment(+ seriesName = cleanSeriesName(title),+ episodeNumber = 0,+ episodeTitle = title.trim()+ )+ }++ private fun seriesKey(providerId: Long, name: String): String =+ "m3u-series:${hashToId("$providerId|${M3uSourceIdentity.groupKey(name)}")}"++ private fun manualCategoryId(providerId: Long, type: ContentType): Long =+ hashToId("m3u-manual-category:$providerId:${type.name}")++ private suspend fun liveDestination(providerId: Long, groupKey: String?): LiveDestination {+ val category = categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name)+ .firstOrNull { category ->+ groupKey?.isNotBlank() == true &&+ M3uSourceIdentity.groupKey(category.name) == groupKey+ }+ return if (category != null) {+ LiveDestination(category.categoryId, category.name)+ } else {+ val uncategorizedId = hashToId("$providerId/LIVE/Uncategorized")+ categoryDao.insertAll(+ listOf(+ CategoryEntity(+ categoryId = uncategorizedId,+ name = "Uncategorized",+ type = ContentType.LIVE,+ providerId = providerId+ )+ )+ )+ LiveDestination(+ id = uncategorizedId,+ name = "Uncategorized"+ )+ }+ }++ private data class LiveDestination(val id: Long, val name: String)++ private fun hashToId(value: String): Long {+ val bytes = MessageDigest.getInstance("SHA-256").digest(value.toByteArray(Charsets.UTF_8))+ var result = 0L+ repeat(8) { index -> result = (result shl 8) or (bytes[index].toLong() and 0xff) }+ return (result and Long.MAX_VALUE).coerceAtLeast(1L)+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.ktindex 53fbcee3..9a8ad188 100644--- a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt+++ b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt@@ -9,6 +9,7 @@ import com.streamvault.data.local.dao.ChannelDaoimport com.streamvault.data.local.dao.EpisodeDaoimport com.streamvault.data.local.dao.MovieCategoryHydrationDaoimport com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.M3uClassificationDaoimport com.streamvault.data.local.dao.ProgramDaoimport com.streamvault.data.local.dao.ProviderDaoimport com.streamvault.data.local.dao.ProviderWorkflowDao@@ -92,6 +93,7 @@ import com.streamvault.domain.model.XtreamConfigimport com.streamvault.domain.repository.EpgRepositoryimport com.streamvault.domain.repository.EpgSourceRepositoryimport com.streamvault.domain.repository.SyncMetadataRepository+import com.streamvault.domain.repository.M3uClassificationRepositoryimport com.streamvault.domain.repository.ProviderSnapshotRepositoryimport com.streamvault.domain.sync.Sectionimport com.streamvault.domain.sync.SyncProgress@@ -215,7 +217,9 @@ class SyncManager @Inject constructor(private val providerWorkLocks: ProviderWorkLockRegistry,private val providerSyncLocks: ProviderSyncLockRegistry,private val stalkerPlaybackCapabilityCache: StalkerPlaybackCapabilityCache,- private val providerSyncWorkScheduler: ProviderSyncWorkScheduler+ private val providerSyncWorkScheduler: ProviderSyncWorkScheduler,+ private val m3uClassificationDao: M3uClassificationDao? = null,+ private val m3uClassificationRepository: M3uClassificationRepository? = null) : ProviderSyncCommands, CatalogHydrationCommands, ProviderSyncStateSource, ProviderSyncLifecycle {private val syncProviderSnapshotAdapter = SyncProviderSnapshotAdapter(providerSnapshotRepository)private val syncStatusPublicationCoordinator = SyncStatusPublicationCoordinator(@@ -402,7 +406,9 @@ class SyncManager @Inject constructor(syncCatalogStore = syncCatalogStore,retryTransient = { block -> retryTransient(block = block) },progress = ::progress,- emitProgress = ::emitProviderProgress+ emitProgress = ::emitProviderProgress,+ classificationDao = m3uClassificationDao,+ classificationRepository = m3uClassificationRepository)private val m3uCatalogExecutor by lazy {M3uCatalogSyncExecutor(diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.kt b/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.ktindex 45a04d7b..f142ff2d 100644--- a/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.kt+++ b/data/src/main/java/com/streamvault/data/sync/SyncManagerM3uImporter.kt@@ -3,8 +3,10 @@ package com.streamvault.data.syncimport android.util.Logimport com.streamvault.data.local.entity.ChannelEntityimport com.streamvault.data.local.entity.MovieEntity+import com.streamvault.data.local.dao.M3uClassificationDaoimport com.streamvault.data.parser.M3uParserimport com.streamvault.data.parser.M3uMediaKind+import com.streamvault.data.parser.M3uSourceIdentityimport com.streamvault.data.parser.M3uVodClassifierimport com.streamvault.data.remote.http.HttpRequestProfileimport com.streamvault.data.remote.http.useCancellableResponse@@ -15,6 +17,9 @@ import com.streamvault.data.util.AdultContentClassifierimport com.streamvault.data.util.UrlSecurityPolicyimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.repository.M3uClassificationRepository+import com.streamvault.domain.repository.M3uClassificationTarget+import com.streamvault.domain.repository.M3uSeriesAssignmentimport com.streamvault.domain.sync.Sectionimport com.streamvault.domain.sync.SyncProgressimport kotlinx.coroutines.NonCancellable@@ -39,7 +44,9 @@ internal class SyncManagerM3uImporter(private val progress: (Long, ((String) -> Unit)?, String) -> Unit,private val emitProgress: (Long, SyncProgress) -> Unit,private val sizeLimits: CatalogSizeLimits = CatalogSizeLimits(),- private val vodClassifier: M3uVodClassifier = M3uVodClassifier()+ private val vodClassifier: M3uVodClassifier = M3uVodClassifier(),+ private val classificationDao: M3uClassificationDao? = null,+ private val classificationRepository: M3uClassificationRepository? = null) {suspend fun importPlaylist(provider: Provider,@@ -74,6 +81,13 @@ internal class SyncManagerM3uImporter(val movieBatch = ArrayList<MovieEntity>(batchSize)val seenLiveStreamIds = if (includeLive) mutableSetOf<Long>() else nullval seenMovieStreamIds = if (includeMovies) mutableSetOf<Long>() else null+ val seriesToReconcile = mutableListOf<Pair<Long, M3uSeriesAssignment?>>()+ val persistedOverrides = classificationDao?.getOverrides(provider.id).orEmpty()+ val itemOverrides = persistedOverrides.associateBy { it.sourceKey }+ // A movie that was automatically classified before the override tables existed may+ // have no source key, but its destination-independent stream id is still recoverable.+ val itemOverridesByStreamId = persistedOverrides.associateBy { it.streamId }+ val categoryRules = classificationDao?.getCategoryRules(provider.id).orEmpty().associateBy { it.groupKey }var header = M3uParser.M3uHeader()var liveCount = 0var movieCount = 0@@ -174,25 +188,73 @@ internal class SyncManagerM3uImporter(val safeLogoUrl = UrlSecurityPolicy.sanitizeImportedAssetUrl(entry.tvgLogo)val safeCatchUpSource = UrlSecurityPolicy.sanitizeImportedAssetUrl(entry.catchUpSource)+ val sourceKey = M3uSourceIdentity.fromEntry(provider.id, entry)+ val sourceStableId = M3uSourceIdentity.stableLongId(provider.id, entry)+ val override = itemOverrides[sourceKey] ?: itemOverridesByStreamId[sourceStableId]+ val groupRule = categoryRules[M3uSourceIdentity.groupKey(entry.groupTitle)]+ val manualTarget = (override?.targetType ?: groupRule?.targetType)+ ?.let { target -> runCatching { M3uClassificationTarget.valueOf(target) }.getOrNull() }+ if (manualTarget == M3uClassificationTarget.SERIES) {+ if (!includeLive) return@parseStreaming+ val groupTitle = entry.groupTitle.ifBlank { "Uncategorized" }+ val stableStreamId = override?.streamId+ ?: sourceStableId+ if (seenLiveStreamIds?.add(stableStreamId) != true) return@parseStreaming+ val categoryId = liveCategories.idFor(groupTitle)+ channelBatch.add(+ ChannelEntity(+ streamId = stableStreamId,+ name = entry.name,+ logoUrl = safeLogoUrl,+ groupTitle = groupTitle,+ categoryId = categoryId,+ categoryName = groupTitle,+ epgChannelId = entry.tvgId ?: entry.tvgName,+ number = entry.tvgChno ?: 0,+ streamUrl = entry.url,+ catchUpSupported = !entry.catchUp.isNullOrBlank() ||+ !entry.catchUpSource.isNullOrBlank() ||+ !entry.timeshift.isNullOrBlank(),+ catchUpDays = entry.catchUpDays ?: 0,+ catchUpSource = safeCatchUpSource,+ providerId = provider.id,+ isAdult = AdultContentClassifier.isAdultCategoryName(groupTitle)+ )+ )+ seriesToReconcile += stableStreamId to override?.toSeriesAssignment()+ liveCount+++ if (channelBatch.size >= batchSize) flushChannelBatch(provider.id, sessionId, channelBatch)+ return@parseStreaming+ }+val mediaClassification = vodClassifier.classify(entry = entry,- override = if (provider.m3uVodClassificationEnabled) null else M3uMediaKind.LIVE+ override = when {+ manualTarget == M3uClassificationTarget.MOVIE -> M3uMediaKind.VOD+ manualTarget == M3uClassificationTarget.LIVE -> M3uMediaKind.LIVE+ provider.m3uVodClassificationEnabled -> null+ else -> M3uMediaKind.LIVE+ })if (mediaClassification.isVod) {if (!includeMovies) return@parseStreaming- val groupTitle = entry.groupTitle.ifBlank { "Uncategorized" }- val stableStreamId = stableId(- providerId = provider.id,- contentType = ContentType.MOVIE,- tvgId = entry.tvgId,- url = entry.url,- title = entry.name,- groupTitle = groupTitle,- hasher = stableLongHasher- )+ val groupTitle = if (manualTarget == M3uClassificationTarget.MOVIE) {+ "Movies"+ } else {+ entry.groupTitle.ifBlank { "Uncategorized" }+ }+ val stableStreamId = override?.streamId+ ?: sourceStableIdif (seenMovieStreamIds?.add(stableStreamId) != true) return@parseStreamingif (movieCount >= sizeLimits.maxMoviesPerProvider) throw CatalogAdmissionExceeded("M3U movie limit exceeded")- val categoryId = movieCategories.idFor(groupTitle)+ val categoryId = if (manualTarget == M3uClassificationTarget.MOVIE) {+ manualCategoryId(provider.id, ContentType.MOVIE, stableLongHasher)+ } else {+ movieCategories.idFor(groupTitle)+ }+ if (manualTarget == M3uClassificationTarget.MOVIE) {+ movieCategories.register("Movies", categoryId)+ }if (movieCategories.count > sizeLimits.maxM3uCategoriesPerType) throw CatalogAdmissionExceeded("M3U movie category limit exceeded")val isAdult = AdultContentClassifier.isAdultCategoryName(groupTitle)movieBatch.add(@@ -217,15 +279,8 @@ internal class SyncManagerM3uImporter(} else {if (!includeLive) return@parseStreamingval groupTitle = entry.groupTitle.ifBlank { "Uncategorized" }- val stableStreamId = stableId(- providerId = provider.id,- contentType = ContentType.LIVE,- tvgId = entry.tvgId,- url = entry.url,- title = entry.name,- groupTitle = groupTitle,- hasher = stableLongHasher- )+ val stableStreamId = override?.streamId+ ?: sourceStableIdif (seenLiveStreamIds?.add(stableStreamId) != true) return@parseStreamingif (liveCount >= sizeLimits.maxChannelsPerProvider) throw CatalogAdmissionExceeded("M3U live-channel limit exceeded")val categoryId = liveCategories.idFor(groupTitle)@@ -287,6 +342,20 @@ internal class SyncManagerM3uImporter(includeMovies = effectiveMovies,afterCatalogApply = afterCatalogApply)+ if (classificationRepository != null) {+ seriesToReconcile.forEach { (streamId, assignment) ->+ when (val result = classificationRepository.classifyChannelByStream(+ provider.id,+ streamId,+ M3uClassificationTarget.SERIES,+ assignment+ )) {+ is com.streamvault.domain.model.Result.Error ->+ warnings += result.message+ else -> Unit+ }+ }+ }} finally {withContext(NonCancellable) {syncCatalogStore.discardStagedImport(provider.id, sessionId)@@ -476,6 +545,19 @@ internal class SyncManagerM3uImporter(}}}++ private fun manualCategoryId(providerId: Long, type: ContentType, hasher: StableLongHasher): Long =+ hasher.hash("m3u-manual-category:$providerId:${type.name}").coerceAtLeast(1L)++ private fun com.streamvault.data.local.entity.M3uClassificationOverrideEntity.toSeriesAssignment(): M3uSeriesAssignment? {+ val name = seriesName?.takeIf(String::isNotBlank) ?: return null+ return M3uSeriesAssignment(+ seriesName = name,+ seasonNumber = seasonNumber ?: 1,+ episodeNumber = episodeNumber ?: 0,+ episodeTitle = episodeTitle+ )+ }}internal class CatalogAdmissionExceeded(message: String) : IllegalStateException(message)diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.kt b/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.ktindex afd8e0b4..f418aefd 100644--- a/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.kt+++ b/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.kt@@ -240,6 +240,10 @@ internal class CategoryAccumulator(return categoryIds.getOrPut(name) { stableId(providerId, type, name, hasher) }}+ fun register(name: String, categoryId: Long) {+ categoryIds.putIfAbsent(name, categoryId)+ }+fun entities(): List<CategoryEntity> {return categoryIds.map { (name, id) ->CategoryEntity(diff --git a/data/src/test/java/com/streamvault/data/parser/M3uSourceIdentityTest.kt b/data/src/test/java/com/streamvault/data/parser/M3uSourceIdentityTest.ktnew file mode 100644index 00000000..78e74f5c--- /dev/null+++ b/data/src/test/java/com/streamvault/data/parser/M3uSourceIdentityTest.kt@@ -0,0 +1,50 @@+package com.streamvault.data.parser++import com.google.common.truth.Truth.assertThat+import org.junit.Test++class M3uSourceIdentityTest {++ @Test+ fun `tvg id is the stable identity across title and URL refresh changes`() {+ val first = entry(+ tvgId = "movie-42",+ name = "Movie 42",+ url = "https://cdn.example.com/movie/42?token=old"+ )+ val refreshed = entry(+ tvgId = "MOVIE-42",+ name = "Movie 42 (HD)",+ url = "https://cdn.example.com/movie/42?token=new"+ )++ assertThat(M3uSourceIdentity.fromEntry(7L, first))+ .isEqualTo(M3uSourceIdentity.fromEntry(7L, refreshed))+ assertThat(M3uSourceIdentity.stableLongId(7L, first))+ .isEqualTo(M3uSourceIdentity.stableLongId(7L, refreshed))+ }++ @Test+ fun `different providers do not share source identities`() {+ val item = entry(tvgId = "same-id", name = "Same title", url = "https://cdn.example.com/item")++ assertThat(M3uSourceIdentity.fromEntry(7L, item))+ .isNotEqualTo(M3uSourceIdentity.fromEntry(8L, item))+ }++ private fun entry(tvgId: String?, name: String, url: String) = M3uParser.M3uEntry(+ name = name,+ groupTitle = "General",+ tvgId = tvgId,+ tvgName = null,+ tvgLogo = null,+ tvgChno = null,+ tvgLanguage = null,+ tvgCountry = null,+ catchUp = null,+ catchUpDays = null,+ catchUpSource = null,+ timeshift = null,+ url = url+ )+}diff --git a/data/src/test/java/com/streamvault/data/repository/M3uClassificationRepositoryTest.kt b/data/src/test/java/com/streamvault/data/repository/M3uClassificationRepositoryTest.ktnew file mode 100644index 00000000..893a1a24--- /dev/null+++ b/data/src/test/java/com/streamvault/data/repository/M3uClassificationRepositoryTest.kt@@ -0,0 +1,226 @@+package com.streamvault.data.repository++import androidx.room.Room+import com.google.common.truth.Truth.assertThat+import com.streamvault.data.local.StreamVaultDatabase+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.ChannelEntity+import com.streamvault.data.local.entity.FavoriteEntity+import com.streamvault.data.local.entity.PlaybackHistoryEntity+import com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.repository.M3uClassificationTarget+import com.streamvault.domain.repository.M3uSeriesAssignment+import kotlinx.coroutines.runBlocking+import kotlinx.coroutines.test.runTest+import org.junit.After+import org.junit.Before+import org.junit.Test+import org.junit.runner.RunWith+import org.robolectric.RobolectricTestRunner+import org.robolectric.RuntimeEnvironment++@RunWith(RobolectricTestRunner::class)+class M3uClassificationRepositoryTest {++ private lateinit var database: StreamVaultDatabase+ private lateinit var repository: M3uClassificationRepositoryImpl++ @Before+ fun setUp() {+ database = Room.inMemoryDatabaseBuilder(+ RuntimeEnvironment.getApplication(),+ StreamVaultDatabase::class.java+ ).allowMainThreadQueries().build()+ runBlocking {+ database.providerDao().insert(+ ProviderEntity(+ id = PROVIDER_ID,+ name = "M3U fixture",+ type = ProviderType.M3U+ )+ )+ }+ repository = M3uClassificationRepositoryImpl(+ providerDao = database.providerDao(),+ channelDao = database.channelDao(),+ movieDao = database.movieDao(),+ seriesDao = database.seriesDao(),+ episodeDao = database.episodeDao(),+ favoriteDao = database.favoriteDao(),+ playbackHistoryDao = database.playbackHistoryDao(),+ categoryDao = database.categoryDao(),+ classificationDao = database.m3uClassificationDao(),+ transactionRunner = com.streamvault.data.local.RoomDatabaseTransactionRunner(database)+ )+ }++ @After+ fun tearDown() {+ database.close()+ }++ @Test+ fun `movie move is atomic and migrates history and favorite back to live`() = runTest {+ insertLiveCategory()+ val channelId = database.channelDao().insert(channel(501L, "Movie source"))+ database.favoriteDao().insert(+ FavoriteEntity(+ providerId = PROVIDER_ID,+ contentId = channelId,+ contentType = ContentType.LIVE+ )+ )+ database.playbackHistoryDao().insertOrUpdate(+ PlaybackHistoryEntity(+ contentId = channelId,+ contentType = ContentType.LIVE,+ providerId = PROVIDER_ID,+ title = "Movie source",+ streamUrl = "https://cdn.example/movie.m3u8",+ resumePositionMs = 12_000L,+ totalDurationMs = 60_000L+ )+ )++ assertThat(repository.classifyChannel(PROVIDER_ID, channelId, M3uClassificationTarget.MOVIE).isSuccess)+ .isTrue()+ assertThat(database.channelDao().getByProviderSync(PROVIDER_ID)).isEmpty()+ val movie = checkNotNull(database.movieDao().getByStreamId(PROVIDER_ID, 501L))+ assertThat(database.playbackHistoryDao().get(movie.id, ContentType.MOVIE.name, PROVIDER_ID)).isNotNull()+ assertThat(database.favoriteDao().get(PROVIDER_ID, movie.id, ContentType.MOVIE.name, null)).isNotNull()+ assertThat(database.m3uClassificationDao().getByStreamId(PROVIDER_ID, 501L)?.targetType)+ .isEqualTo(M3uClassificationTarget.MOVIE.name)++ assertThat(repository.moveMovieBackToLive(PROVIDER_ID, movie.id).isSuccess).isTrue()+ val restored = database.channelDao().getByProviderSync(PROVIDER_ID).single()+ assertThat(restored.streamId).isEqualTo(501L)+ assertThat(database.movieDao().getByStreamId(PROVIDER_ID, 501L)).isNull()+ assertThat(database.playbackHistoryDao().get(restored.id, ContentType.LIVE.name, PROVIDER_ID)).isNotNull()+ assertThat(database.favoriteDao().get(PROVIDER_ID, restored.id, ContentType.LIVE.name, null)).isNotNull()+ assertThat(database.m3uClassificationDao().getByStreamId(PROVIDER_ID, 501L)?.targetType)+ .isEqualTo(M3uClassificationTarget.LIVE.name)+ }++ @Test+ fun `keeping an empty category live restores its existing movie projections`() = runTest {+ insertLiveCategory()+ database.channelDao().insert(channel(502L, "Category movie"))++ assertThat(+ repository.classifyCategory(PROVIDER_ID, LIVE_CATEGORY_ID, M3uClassificationTarget.MOVIE)+ .getOrNull()+ ).isEqualTo(1)+ assertThat(database.channelDao().getByProviderSync(PROVIDER_ID)).isEmpty()+ assertThat(database.movieDao().getByStreamId(PROVIDER_ID, 502L)).isNotNull()++ assertThat(+ repository.classifyCategory(PROVIDER_ID, LIVE_CATEGORY_ID, M3uClassificationTarget.LIVE)+ .getOrNull()+ ).isEqualTo(1)+ assertThat(database.movieDao().getByStreamId(PROVIDER_ID, 502L)).isNull()+ assertThat(database.channelDao().getByProviderSync(PROVIDER_ID).single().streamId)+ .isEqualTo(502L)+ }++ @Test+ fun `series category creates separate seasons and episodes and moves the parent back atomically`() = runTest {+ insertLiveCategory()+ database.channelDao().insert(channel(601L, "Example Show S01E01"))+ database.channelDao().insert(channel(602L, "Example Show S02E03"))++ val suggestions = repository.getCategoryItems(PROVIDER_ID, LIVE_CATEGORY_ID).getOrNull()+ assertThat(suggestions).hasSize(2)+ assertThat(suggestions!!.map { it.suggestedAssignment.episodeNumber })+ .containsExactly(1, 3)++ assertThat(+ repository.classifyCategory(PROVIDER_ID, LIVE_CATEGORY_ID, M3uClassificationTarget.SERIES)+ .getOrNull()+ ).isEqualTo(2)++ val series = database.seriesDao().getByProviderSync(PROVIDER_ID).single()+ val episodes = database.episodeDao().getEntitiesBySeriesSync(series.id)+ assertThat(series.name).isEqualTo("Example Show")+ assertThat(episodes.map { it.seasonNumber to it.episodeNumber })+ .containsExactly(1 to 1, 2 to 3)+ .inOrder()+ assertThat(database.channelDao().getByProviderSync(PROVIDER_ID)).isEmpty()++ assertThat(repository.moveSeriesBackToLive(PROVIDER_ID, series.id).isSuccess).isTrue()+ assertThat(database.seriesDao().getByProviderSync(PROVIDER_ID)).isEmpty()+ assertThat(database.episodeDao().getEntitiesBySeriesSync(series.id)).isEmpty()+ assertThat(database.channelDao().getByProviderSync(PROVIDER_ID).map { it.streamId })+ .containsExactly(601L, 602L)+ }++ @Test+ fun `unresolved episode title is surfaced without inventing an episode number`() = runTest {+ insertLiveCategory()+ database.channelDao().insert(channel(603L, "Mystery Show Tập Cuối"))++ val suggestion = repository.getCategoryItems(PROVIDER_ID, LIVE_CATEGORY_ID)+ .getOrNull()!!+ .single()++ assertThat(suggestion.suggestedAssignment.seriesName).isEqualTo("Mystery Show")+ assertThat(suggestion.suggestedAssignment.episodeNumber).isEqualTo(0)+ assertThat(suggestion.suggestedAssignment.episodeTitle).isEqualTo("Mystery Show Tập Cuối")+ }++ @Test+ fun `category review assignments can create multiple manually named series`() = runTest {+ insertLiveCategory()+ val firstId = database.channelDao().insert(channel(604L, "Part one"))+ val secondId = database.channelDao().insert(channel(605L, "Part two"))++ assertThat(+ repository.classifyCategory(+ providerId = PROVIDER_ID,+ categoryId = LIVE_CATEGORY_ID,+ target = M3uClassificationTarget.SERIES,+ seriesAssignments = mapOf(+ firstId to M3uSeriesAssignment("First series", seasonNumber = 1, episodeNumber = 7),+ secondId to M3uSeriesAssignment("Second series", seasonNumber = 3, episodeNumber = 2)+ )+ ).getOrNull()+ ).isEqualTo(2)++ val seriesByName = database.seriesDao().getByProviderSync(PROVIDER_ID).associateBy { it.name }+ assertThat(seriesByName.keys)+ .containsExactly("First series", "Second series")+ assertThat(database.episodeDao().getEntitiesBySeriesSync(seriesByName.getValue("First series").id).single().episodeNumber)+ .isEqualTo(7)+ assertThat(database.episodeDao().getEntitiesBySeriesSync(seriesByName.getValue("Second series").id).single().seasonNumber)+ .isEqualTo(3)+ }++ private suspend fun insertLiveCategory() {+ database.categoryDao().insertAll(+ listOf(+ CategoryEntity(+ categoryId = LIVE_CATEGORY_ID,+ name = "Fixture Group",+ type = ContentType.LIVE,+ providerId = PROVIDER_ID+ )+ )+ )+ }++ private fun channel(streamId: Long, name: String) = ChannelEntity(+ streamId = streamId,+ name = name,+ groupTitle = "Fixture Group",+ categoryId = LIVE_CATEGORY_ID,+ categoryName = "Fixture Group",+ streamUrl = "https://cdn.example/$streamId.m3u8",+ providerId = PROVIDER_ID+ )++ private companion object {+ const val PROVIDER_ID = 7L+ const val LIVE_CATEGORY_ID = 70L+ }+}diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 8d48086b..6d790d81 100644--- a/docs/CHANGELOG.md+++ b/docs/CHANGELOG.md@@ -19,7 +19,7 @@ All notable product changes are recorded in this document.- Added Stalker catalog readiness tracking, persisted portal capability state, diagnostics, and playback recovery telemetry.- Added generic Stalker catalog and playback support across Live TV, VOD, Movies, and Series.- Added Stalker VOD browsing with paged loading, on-demand catalog expansion, and complete-category loading as an option.-- Added M3U VOD classification to distinguish movie and series entries during playlist imports.+- Added M3U-only VOD classification and manual organization: users can classify imported entries as Movies or Series from Live TV long-press menus, review and group episodes into series with editable names, seasons, and episode numbers, and move items back to Live TV; persisted provider/source overrides survive refreshes and use app-owned destinations without exposing source group names or emojis, while non-M3U providers remain unchanged.- Added bounded XMLTV ingestion with deterministic timezone-policy handling for large or inconsistent guide feeds.- Added capability-based provider routing with typed configurations and stable provider identities across supported sources.- Added checkpointed, idempotent backup restore with semantic ID mapping, partial-result reporting, and bounded import validation.diff --git a/domain/src/main/java/com/streamvault/domain/repository/M3uClassificationRepository.kt b/domain/src/main/java/com/streamvault/domain/repository/M3uClassificationRepository.ktnew file mode 100644index 00000000..9a7c7b3b--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/repository/M3uClassificationRepository.kt@@ -0,0 +1,60 @@+package com.streamvault.domain.repository++import com.streamvault.domain.model.Result++enum class M3uClassificationTarget {+ LIVE,+ MOVIE,+ SERIES+}++data class M3uSeriesAssignment(+ val seriesName: String,+ val seasonNumber: Int = 1,+ /** Zero is reserved for an episode whose number could not be resolved automatically. */+ val episodeNumber: Int? = 1,+ val episodeTitle: String? = null+)++data class M3uCategoryItem(+ val channelId: Long,+ val title: String,+ val suggestedAssignment: M3uSeriesAssignment+)++/**+ * User-owned classification overrides for M3U entries.+ *+ * This repository is intentionally M3U-specific. Provider implementations for Xtream,+ * Stalker, and Jellyfin must never expose or call these operations.+ */+interface M3uClassificationRepository {+ suspend fun getCategoryItems(providerId: Long, categoryId: Long): Result<List<M3uCategoryItem>>++ suspend fun classifyChannel(+ providerId: Long,+ channelId: Long,+ target: M3uClassificationTarget,+ series: M3uSeriesAssignment? = null+ ): Result<Unit>++ suspend fun classifyChannelByStream(+ providerId: Long,+ streamId: Long,+ target: M3uClassificationTarget,+ series: M3uSeriesAssignment? = null+ ): Result<Unit>++ suspend fun classifyCategory(+ providerId: Long,+ categoryId: Long,+ target: M3uClassificationTarget,+ seriesAssignments: Map<Long, M3uSeriesAssignment> = emptyMap()+ ): Result<Int>++ suspend fun moveMovieBackToLive(providerId: Long, movieId: Long): Result<Unit>++ suspend fun moveEpisodeBackToLive(providerId: Long, episodeId: Long): Result<Unit>++ suspend fun moveSeriesBackToLive(providerId: Long, seriesId: Long): Result<Unit>+}