Merge pull request #489 from VPlanPlus-Project/487-rebuild-timetable-updater

487 rebuild timetable updater

Author: Julius-Babies

composeApp/src/commonMain/kotlin/plus/vplan/app/domain/model/populated/PopulatedDay.kt

@@ -19,7 +19,7 @@ import plus.vplan.app.core.model.Holiday
 import plus.vplan.app.core.model.Homework
 import plus.vplan.app.core.model.Lesson
 import plus.vplan.app.core.model.Timetable
-import plus.vplan.app.utils.plus
+import plus.vplan.app.core.utils.date.plus
 import kotlin.time.Duration.Companion.days
 
 data class PopulatedDay(
@@ -87,7 +87,11 @@ class DayPopulator(
                             weekIndex = timetableWeek?.weekIndex ?: 0,
                             dayOfWeek = day.date.dayOfWeek
                         )
-                    }.map { it.toList() }
+                    }.map { timetableLessons ->
+                        timetableLessons
+                            .toList()
+                            .filter { timetableLesson -> timetableLesson.weekType == null || timetableLesson.weekType == day.week?.weekType }
+                    }
                 }
 
         val substitution = when (context) {

composeApp/src/commonMain/kotlin/plus/vplan/app/domain/usecase/GetDayUseCase.kt

@@ -4,20 +4,14 @@ package plus.vplan.app.domain.usecase
 
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.distinctUntilChangedBy
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.map
 import kotlinx.datetime.LocalDate
-import kotlinx.datetime.isoDayNumber
 import plus.vplan.app.core.data.day.DayRepository
-import plus.vplan.app.core.model.Day
 import plus.vplan.app.core.model.Profile
 import plus.vplan.app.core.model.School
 import plus.vplan.app.domain.model.populated.DayPopulator
 import plus.vplan.app.domain.model.populated.PopulatedDay
 import plus.vplan.app.domain.model.populated.PopulationContext
-import plus.vplan.app.utils.plus
-import kotlin.time.Duration.Companion.days
 
 class GetDayUseCase(
     private val dayRepository: DayRepository,
@@ -26,16 +20,6 @@ class GetDayUseCase(
     operator fun invoke(profile: Profile, date: LocalDate): Flow<PopulatedDay> {
         val school: School.AppSchool = profile.school
         return dayRepository.getBySchool(school, date)
-            .map { it ?: Day(
-                id = Day.buildId(school.id, date),
-                date = date,
-                school = school,
-                week = null,
-                info = null,
-                dayType = if (date.dayOfWeek.isoDayNumber > school.daysPerWeek) Day.DayType.WEEKEND else Day.DayType.REGULAR,
-                nextSchoolDay = date + 1.days
-            ) }
-            .distinctUntilChangedBy { "${it.id}|${it.week?.id}|${it.info}|${it.dayType}" }
             .flatMapLatest { day ->
                 dayPopulator.populateSingle(day, PopulationContext.Profile(profile))
             }

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/calendar/di/calendarModule.kt

@@ -3,6 +3,7 @@ package plus.vplan.app.feature.calendar.di
 import org.koin.core.module.dsl.singleOf
 import org.koin.core.module.dsl.viewModelOf
 import org.koin.dsl.module
+import plus.vplan.app.feature.calendar.domain.usecase.DownloadDayIfNecessaryUseCase
 import plus.vplan.app.feature.calendar.domain.usecase.GetFirstLessonStartUseCase
 import plus.vplan.app.feature.calendar.domain.usecase.GetHolidaysUseCase
 import plus.vplan.app.feature.calendar.domain.usecase.GetLastDisplayTypeUseCase
@@ -13,6 +14,7 @@ val calendarModule = module {
     singleOf(::GetLastDisplayTypeUseCase)
     singleOf(::SetLastDisplayTypeUseCase)
     singleOf(::GetFirstLessonStartUseCase)
+    singleOf(::DownloadDayIfNecessaryUseCase)
     singleOf(::GetHolidaysUseCase)
 
     viewModelOf(::CalendarViewModel)

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/calendar/domain/usecase/DownloadDayIfNecessaryUseCase.kt

@@ -0,0 +1,43 @@
+@file:OptIn(FlowPreview::class)
+
+package plus.vplan.app.feature.calendar.domain.usecase
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import kotlinx.datetime.LocalDate
+import plus.vplan.app.core.data.timetable.TimetableRepository
+import plus.vplan.app.core.model.School
+import plus.vplan.app.core.model.Timetable
+import plus.vplan.app.core.sync.domain.usecase.sp24.UpdateTimetableUseCase
+import plus.vplan.app.core.utils.date.now
+
+class DownloadDayIfNecessaryUseCase(
+    private val updateTimetableUseCase: UpdateTimetableUseCase,
+    private val timetableRepository: TimetableRepository,
+) {
+
+    private val mutex = Mutex()
+    val isRunning: StateFlow<Boolean>
+        field = MutableStateFlow(false)
+    suspend operator fun invoke(date: LocalDate, school: School.AppSchool) = withContext(Dispatchers.Default) {
+        if (date > LocalDate.now()) return@withContext
+        mutex.withLock {
+            val timetables = timetableRepository.getTimetables(school).first()
+                .filter { it.week.start <= date }
+            if (timetables.isEmpty() || timetables.maxBy { it.week.start }.dataState == Timetable.HasData.Unknown) {
+                try {
+                    isRunning.value = true
+                    updateTimetableUseCase.updateTimetableRelatedToDate(date, school)
+                } finally {
+                    isRunning.value = false
+                }
+            }
+        }
+    }
+}

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/calendar/ui/CalendarScreen.kt

@@ -44,6 +44,7 @@ import androidx.compose.material3.FilledTonalIconButton
 import androidx.compose.material3.FloatingActionButton
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
+import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.LocalTextStyle
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -356,6 +357,13 @@ private fun CalendarScreenContent(
                             if (cause == DateSelectionCause.DayClick && scrollProgress == 2f) scrollProgress = 0f
                         } }
                     )
+                    AnimatedVisibility(
+                        visible = state.isTimetableUpdating,
+                        enter = expandVertically(),
+                        exit = shrinkVertically()
+                    ) {
+                        LinearProgressIndicator(Modifier.fillMaxWidth())
+                    }
                     HorizontalDivider()
                     val isUserDraggingPager = pagerState.interactionSource.collectIsDraggedAsState().value
                     val isUserDraggingList = lazyListState.interactionSource.collectIsDraggedAsState().value

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/calendar/ui/CalendarViewModel.kt

@@ -32,15 +32,17 @@ import plus.vplan.app.core.model.Profile
 import plus.vplan.app.core.model.Week
 import plus.vplan.app.core.utils.date.atStartOfWeek
 import plus.vplan.app.core.utils.date.now
+import plus.vplan.app.core.utils.date.plus
 import plus.vplan.app.domain.usecase.GetCurrentDateTimeUseCase
 import plus.vplan.app.domain.usecase.GetDayUseCase
+import plus.vplan.app.feature.calendar.domain.usecase.DownloadDayIfNecessaryUseCase
 import plus.vplan.app.feature.calendar.domain.usecase.GetFirstLessonStartUseCase
 import plus.vplan.app.feature.calendar.domain.usecase.GetHolidaysUseCase
 import plus.vplan.app.feature.calendar.domain.usecase.GetLastDisplayTypeUseCase
 import plus.vplan.app.feature.calendar.domain.usecase.SetLastDisplayTypeUseCase
 import plus.vplan.app.utils.atStartOfMonth
 import plus.vplan.app.utils.inWholeMinutes
-import plus.vplan.app.utils.plus
+import kotlin.comparisons.nullsLast
 import kotlin.time.Duration.Companion.days
 
 class CalendarViewModel(
@@ -52,6 +54,7 @@ class CalendarViewModel(
     private val getFirstLessonStartUseCase: GetFirstLessonStartUseCase,
     private val getHolidaysUseCase: GetHolidaysUseCase,
     private val keyValueRepository: KeyValueRepository,
+    private val downloadDayIfNecessaryUseCase: DownloadDayIfNecessaryUseCase,
 ) : ViewModel() {
     val state: StateFlow<CalendarState>
         field = MutableStateFlow(CalendarState())
@@ -67,6 +70,12 @@ class CalendarViewModel(
                 }
         }
 
+        viewModelScope.launch {
+            downloadDayIfNecessaryUseCase.isRunning.collect { isRunning ->
+                state.update { it.copy(isTimetableUpdating = isRunning) }
+            }
+        }
+
         viewModelScope.launch {
             getLastDisplayTypeUseCase().collect { displayType ->
                 state.update { it.copy(displayType = displayType) }
@@ -110,6 +119,9 @@ class CalendarViewModel(
 
     private fun launchDay(profile: Profile, date: LocalDate): Job {
         return viewModelScope.launch {
+            launch {
+                downloadDayIfNecessaryUseCase(date, profile.school)
+            }
             keyValueRepository.get(Keys.forceReducedCalendarView.key)
                 .map { it.toBoolean() }
                 .collectLatest { forceReduced ->
@@ -199,7 +211,8 @@ data class CalendarState(
     val start: LocalTime = LocalTime(0, 0),
     val holidays: Set<LocalDate> = emptySet(),
     val selectorDays: Map<LocalDate, DateSelectorDay> = emptyMap(),
-    val calendarDays: Map<LocalDate, CalendarDay> = emptyMap()
+    val calendarDays: Map<LocalDate, CalendarDay> = emptyMap(),
+    val isTimetableUpdating: Boolean = false,
 )
 
 sealed class CalendarEvent {
@@ -228,7 +241,7 @@ data class CalendarDay(
     val week: Week? = null,
     val assessments: List<Assessment> = emptyList(),
     val homework: List<Homework> = emptyList(),
-    val lessons: LessonRendering? = null
+    val lessons: LessonRendering? = null,
 )
 
 suspend fun Collection<Lesson>.calculateLayouting(): List<LessonLayoutingInfo> {
@@ -238,7 +251,12 @@ suspend fun Collection<Lesson>.calculateLayouting(): List<LessonLayoutingInfo> {
     return withContext(Dispatchers.Default) {
 
         val lessons = this@calculateLayouting
-            .filter { it.lessonTime != null }
+            .filter { lesson -> lesson.lessonTime != null }
+            .sortedWith(
+                compareBy<Lesson> { lesson -> lesson.lessonTime!!.start }
+                    .thenBy(nullsLast()) { lesson -> lesson.subject }
+                    .thenBy(nullsLast()) { lesson -> lesson.teachers.map { it.name }.sorted().joinToString() }
+            )
             .sortedBy { it.lessonTime!!.start.inWholeMinutes() }
 
         data class Event(val time: Int, val isStart: Boolean, val lesson: Lesson)

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/calendar/ui/components/date_selector/Month.kt

@@ -12,9 +12,9 @@ import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import kotlinx.datetime.LocalDate
+import plus.vplan.app.core.utils.date.plus
 import plus.vplan.app.feature.calendar.ui.DateSelectorDay
 import plus.vplan.app.utils.minus
-import plus.vplan.app.utils.plus
 import kotlin.time.Duration.Companion.days
 
 @Composable
@@ -27,7 +27,7 @@ fun Month(
     scrollProgress: Float,
     onDateSelected: (DateSelectionCause, LocalDate) -> Unit = { _, _ -> },
 ) {
-    var weekRowHeight = remember(scrollProgress, containerMaxHeight) { if (scrollProgress <= 1f) weekHeightDefault * scrollProgress
+    val weekRowHeight = remember(scrollProgress, containerMaxHeight) { if (scrollProgress <= 1f) weekHeightDefault * scrollProgress
     else (containerMaxHeight / 5) * (scrollProgress/2).coerceIn(0f, 1f) }
 
     Column(Modifier.fillMaxWidth()) {

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/calendar/ui/components/date_selector/Week.kt

@@ -8,8 +8,8 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.Dp
 import kotlinx.datetime.LocalDate
+import plus.vplan.app.core.utils.date.plus
 import plus.vplan.app.feature.calendar.ui.DateSelectorDay
-import plus.vplan.app.utils.plus
 import kotlin.time.Duration.Companion.days
 
 @Composable

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/calendar/ui/components/date_selector/WeekScroller.kt

@@ -14,9 +14,9 @@ import kotlinx.datetime.plus
 import kotlinx.datetime.until
 import plus.vplan.app.core.utils.date.atStartOfWeek
 import plus.vplan.app.core.utils.date.now
+import plus.vplan.app.core.utils.date.plus
 import plus.vplan.app.feature.calendar.ui.DateSelectorDay
 import plus.vplan.app.utils.minus
-import plus.vplan.app.utils.plus
 import kotlin.time.Duration.Companion.days
 
 const val WEEK_PAGER_SIZE = Int.MAX_VALUE

composeApp/src/commonMain/kotlin/plus/vplan/app/feature/home/ui/HomeScreen.kt

@@ -986,7 +986,7 @@ private fun RefreshIndicator(
 @Composable
 private fun RefreshIndicatorPreview() {
     AppTheme(dynamicColor = false) {
-        RefreshIndicator(HomeState.CurrentUpdateStage.Timetable)
+        RefreshIndicator(HomeState.CurrentUpdateStage.Timetable(HomeState.CurrentUpdateStage.Timetable.ForWeek.Next))
     }
 }