Obsłuż wielodniowe kursy kierowcy

app/build.gradle.kts

@@ -34,8 +34,8 @@ android {
         applicationId = "pl.firmatpp.kierowca"
         minSdk = 26
         targetSdk = 35
-        versionCode = 101
-        versionName = "1.0.48"
+        versionCode = 103
+        versionName = "1.0.50"
         setProperty("archivesBaseName", "pl.firmatpp.kierowca")
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 

app/src/main/java/pl/firmatpp/kierowca/data/model/DriverModels.kt

@@ -244,6 +244,7 @@ data class RealtimeStatusBody(
 data class DriverRouteDto(
     val id: String,
     val routeDate: String? = null,
+    val unloadingDate: String? = null,
     val startsAt: String,
     val originName: String,
     val destinationName: String,

app/src/main/java/pl/firmatpp/kierowca/data/sync/DriverSyncRepository.kt

@@ -3,6 +3,7 @@ package pl.firmatpp.kierowca.data.sync
 import android.content.Context
 import com.google.gson.Gson
 import java.io.IOException
+import java.time.LocalDate
 import pl.firmatpp.kierowca.data.DriverRepository
 import pl.firmatpp.kierowca.data.model.BootstrapResponse
 import pl.firmatpp.kierowca.data.model.DriverRouteDto
@@ -72,8 +73,8 @@ class DriverSyncRepository(
             ),
         )
 
-        val selectedDate = date ?: return
-        val cachedBootstrap = dao.bootstrap(selectedDate) ?: return
+        (routeVisibleDates(route) + listOfNotNull(date)).distinct().forEach { selectedDate ->
+            val cachedBootstrap = dao.bootstrap(selectedDate) ?: return@forEach
             val response = gson.fromJson(cachedBootstrap.payloadJson, BootstrapResponse::class.java)
             val updatedRoutes = response.routes.today.map { item -> if (item.id == route.id) route else item }
             dao.upsertBootstrap(
@@ -85,6 +86,7 @@ class DriverSyncRepository(
                 ),
             )
         }
+    }
 
     suspend fun fetchSyncState(date: String?, routeId: String?): SyncStateResponse =
         repository.syncState(date, routeId)
@@ -146,6 +148,18 @@ class DriverSyncRepository(
 
     private fun currentDateFallback(): String = java.time.LocalDate.now().toString()
 
+    private fun routeVisibleDates(route: DriverRouteDto): List<String> {
+        val start = route.routeDate?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: return emptyList()
+        val end = route.unloadingDate
+            ?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            ?.takeUnless { it.isBefore(start) }
+            ?: start
+
+        return generateSequence(start) { date -> date.plusDays(1).takeIf { !it.isAfter(end) } }
+            .map(LocalDate::toString)
+            .toList()
+    }
+
     companion object {
         const val SCOPE_ROUTES = "routes"
         const val SCOPE_ROUTE_DETAIL = "route_detail"

app/src/main/java/pl/firmatpp/kierowca/ui/DriverApp.kt

@@ -281,7 +281,7 @@ fun DriverApp(
                 title = "Waga załadunku",
                 stage = "loading",
                 weightLabel = "Waga z wagi",
-                submitLabel = "Rozpocznij kurs",
+                submitLabel = "Załaduj",
                 showWeightInput = true,
                 showPhotoActions = false,
                 showPhotoGrid = false,
@@ -295,10 +295,10 @@ fun DriverApp(
             )
             DriverScreen.FinishRoute -> RouteStageScreen(
                 state = state,
-                title = "Zakończ kurs",
+                title = "Rozładunek",
                 stage = "unloading",
                 weightLabel = "Waga na rozładunku",
-                submitLabel = "Zakończ kurs",
+                submitLabel = "Rozładuj",
                 onBack = viewModel::back,
                 onWeightChange = viewModel::updateRouteStageWeight,
                 onUpload = { uri, source, metadata -> viewModel.uploadPhoto(uri, source, metadata, "unloading") },
@@ -1053,10 +1053,23 @@ private fun LeaveCalendarScreen(
     val context = LocalContext.current
     val listState = rememberLazyListState()
     val months = remember(state.leaveCalendarLoadedUntil) { leaveCalendarMonths(state.leaveCalendarLoadedUntil) }
-    var detailsDate by remember { mutableStateOf<LocalDate?>(null) }
-    val detailsEntries = detailsDate
-        ?.let { DriverLeaveRequestUiRules.calendarEntriesForDate(state.leaveCalendarEntries, it) }
-        .orEmpty()
+    var showConflictDetails by remember { mutableStateOf(false) }
+    val selectedConflictEntries = remember(
+        state.leaveCalendarEntries,
+        state.leaveCalendarHasSelection,
+        state.leaveRequestDateFrom,
+        state.leaveRequestDateTo,
+    ) {
+        if (state.leaveCalendarHasSelection) {
+            DriverLeaveRequestUiRules.calendarEntriesForRange(
+                entries = state.leaveCalendarEntries,
+                dateFrom = state.leaveRequestDateFrom,
+                dateTo = state.leaveRequestDateTo,
+            )
+        } else {
+            emptyList()
+        }
+    }
     val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
 
     LaunchedEffect(months.size, state.leaveCalendarLoading) {
@@ -1074,6 +1087,8 @@ private fun LeaveCalendarScreen(
         bottomBar = {
             LeaveCalendarContinueBar(
                 state = state,
+                conflictCount = selectedConflictEntries.size,
+                onShowConflicts = { showConflictDetails = true },
                 onContinue = onContinue,
             )
         },
@@ -1093,11 +1108,8 @@ private fun LeaveCalendarScreen(
                     selectedFrom = state.leaveRequestDateFrom,
                     selectedTo = state.leaveRequestDateTo,
                     hasSelection = state.leaveCalendarHasSelection,
-                    onDayClick = { date, entries ->
+                    onDayClick = { date, _ ->
                         onDateSelected(date.toString())
-                        if (entries.isNotEmpty()) {
-                            detailsDate = date
-                        }
                     },
                 )
             }
@@ -1121,15 +1133,15 @@ private fun LeaveCalendarScreen(
         }
     }
 
-    if (detailsDate != null && detailsEntries.isNotEmpty()) {
+    if (showConflictDetails && selectedConflictEntries.isNotEmpty()) {
         ModalBottomSheet(
-            onDismissRequest = { detailsDate = null },
+            onDismissRequest = { showConflictDetails = false },
             sheetState = sheetState,
             containerColor = TppTheme.colors.card,
         ) {
             LeaveCalendarDetailsSheet(
-                date = detailsDate,
-                entries = detailsEntries,
+                title = "Urlopy w wybranym terminie",
+                entries = selectedConflictEntries,
                 onCall = { dialUri ->
                     context.startActivity(Intent(Intent.ACTION_DIAL, Uri.parse(dialUri)))
                 },
@@ -1139,7 +1151,12 @@ private fun LeaveCalendarScreen(
 }
 
 @Composable
-private fun LeaveCalendarContinueBar(state: DriverUiState, onContinue: () -> Unit) {
+private fun LeaveCalendarContinueBar(
+    state: DriverUiState,
+    conflictCount: Int,
+    onShowConflicts: () -> Unit,
+    onContinue: () -> Unit,
+) {
     val selectionText = when {
         !state.leaveCalendarHasSelection -> "Wybierz pierwszy dzień urlopu"
         else -> leaveDateRange(state.leaveRequestDateFrom, state.leaveRequestDateTo)
@@ -1178,6 +1195,28 @@ private fun LeaveCalendarContinueBar(state: DriverUiState, onContinue: () -> Uni
                 Text("Dalej", fontWeight = FontWeight.Bold)
             }
         }
+        if (state.leaveCalendarHasSelection && conflictCount > 0) {
+            Row(
+                Modifier
+                    .fillMaxWidth()
+                    .background(TppTheme.colors.warningContainer, RoundedCornerShape(4.dp))
+                    .border(1.dp, TppTheme.colors.warningOutline, RoundedCornerShape(4.dp))
+                    .padding(horizontal = 12.dp, vertical = 10.dp),
+                horizontalArrangement = Arrangement.spacedBy(10.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Icon(Icons.Outlined.Info, contentDescription = null, tint = Color(0xFF7A5A00), modifier = Modifier.size(20.dp))
+                Text(
+                    "Nakłada się z ${leaveConflictCountLabel(conflictCount)}",
+                    color = Color(0xFF7A5A00),
+                    fontWeight = FontWeight.Bold,
+                    modifier = Modifier.weight(1f),
+                )
+                TextButton(onClick = onShowConflicts) {
+                    Text("Zobacz", color = TppTheme.colors.forest, fontWeight = FontWeight.Bold)
+                }
+            }
+        }
     }
 }
 
@@ -1307,7 +1346,7 @@ private fun LeaveCalendarDayCell(
 
 @Composable
 private fun LeaveCalendarDetailsSheet(
-    date: LocalDate?,
+    title: String,
     entries: List<DriverLeaveCalendarEntryDto>,
     onCall: (String) -> Unit,
 ) {
@@ -1316,7 +1355,7 @@ private fun LeaveCalendarDetailsSheet(
         verticalArrangement = Arrangement.spacedBy(12.dp),
     ) {
         Text(
-            date?.let { DateTimeFormatter.ofPattern("d MMMM yyyy", Locale("pl", "PL")).format(it) } ?: "Urlopy w tym dniu",
+            title,
             color = TppTheme.colors.ink,
             fontWeight = FontWeight.Bold,
             fontSize = 22.sp,
@@ -1991,6 +2030,8 @@ private fun StitchRouteCard(route: DriverRouteDto, onRoute: (String) -> Unit) {
                                 )
                             }
                         }
+                        Spacer(Modifier.height(12.dp))
+                        RouteScheduleLabel(route)
                         Spacer(Modifier.height(if (compactWidth) 18.dp else 26.dp))
                         RouteTimeline(display.origin, display.destination)
                     }
@@ -2022,6 +2063,21 @@ private fun StatusChip(status: String, color: Color) {
     )
 }
 
+@Composable
+private fun RouteScheduleLabel(route: DriverRouteDto) {
+    Text(
+        routeScheduleSummary(route),
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(TppTheme.colors.panel, RoundedCornerShape(4.dp))
+            .padding(horizontal = 10.dp, vertical = 8.dp),
+        color = TppTheme.colors.muted,
+        fontFamily = FontFamily.Monospace,
+        fontWeight = FontWeight.SemiBold,
+        style = MaterialTheme.typography.labelMedium,
+    )
+}
+
 @Composable
 private fun RouteTimeline(origin: String, destination: String) {
     Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(14.dp)) {
@@ -2735,9 +2791,19 @@ private fun RouteLifecycleSection(
     val steps = routeFlowSteps(route, routeActions)
     val callout = routeSyncCallout(routeActions)
     val action = routeLifecyclePrimaryAction(route, selectedDate)
+    val instruction = routeTodayInstruction(route, selectedDate)
 
     Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(12.dp)) {
         RouteFlowStepper(steps)
+        if (instruction != null) {
+            RouteStateMessage(
+                text = instruction,
+                icon = Icons.Outlined.Info,
+                container = TppTheme.colors.panel,
+                outline = TppTheme.colors.outline,
+                color = TppTheme.colors.ink,
+            )
+        }
         if (!feedback.isNullOrBlank()) {
             RouteStateMessage(
                 text = feedback,
@@ -2846,6 +2912,15 @@ private fun RouteFlowStepItem(step: RouteFlowStepUi, modifier: Modifier = Modifi
             maxLines = 2,
             overflow = TextOverflow.Ellipsis,
         )
+        if (step.dateLabel != null) {
+            Text(
+                step.dateLabel,
+                color = TppTheme.colors.muted,
+                fontFamily = FontFamily.Monospace,
+                fontWeight = FontWeight.SemiBold,
+                style = MaterialTheme.typography.labelSmall,
+            )
+        }
         Text(
             step.stateLabel,
             color = color,
@@ -2926,6 +3001,9 @@ private fun photoCountLabel(count: Int): String =
         else -> "zdjęć"
     }
 
+private fun leaveConflictCountLabel(count: Int): String =
+    if (count == 1) "1 urlopem" else "$count urlopami"
+
 @Composable
 private fun ManifestSection(route: DriverRouteDto, selectedDate: String, onNavigate: (NavigationPointDto) -> Unit) {
     val stripColor = routeStatusColor(route.status)
@@ -2954,6 +3032,7 @@ private fun ManifestSection(route: DriverRouteDto, selectedDate: String, onNavig
                         fontWeight = FontWeight.Bold,
                         color = TppTheme.colors.ink,
                     )
+                    RouteScheduleLabel(route)
                 }
             }
             HorizontalDivider(color = TppTheme.colors.outline.copy(alpha = 0.65f))

app/src/main/java/pl/firmatpp/kierowca/ui/DriverLeaveRequestUiRules.kt

@@ -61,6 +61,19 @@ object DriverLeaveRequestUiRules {
             from != null && to != null && !date.isBefore(from) && !date.isAfter(to)
         }
 
+    fun calendarEntriesForRange(entries: List<DriverLeaveCalendarEntryDto>, dateFrom: String, dateTo: String): List<DriverLeaveCalendarEntryDto> {
+        val selectedFrom = runCatching { LocalDate.parse(dateFrom) }.getOrNull() ?: return emptyList()
+        val selectedTo = runCatching { LocalDate.parse(dateTo) }.getOrNull() ?: return emptyList()
+        val from = minOf(selectedFrom, selectedTo)
+        val to = maxOf(selectedFrom, selectedTo)
+
+        return entries.filter { entry ->
+            val entryFrom = entry.dateFrom?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            val entryTo = entry.dateTo?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+            entryFrom != null && entryTo != null && !entryTo.isBefore(from) && !entryFrom.isAfter(to)
+        }
+    }
+
     fun phoneDialUri(phoneNumber: String?): String? {
         val raw = phoneNumber?.trim().orEmpty()
         if (raw.isBlank()) return null

app/src/main/java/pl/firmatpp/kierowca/ui/DriverUiRules.kt

@@ -34,6 +34,7 @@ data class RouteFlowStepUi(
     val title: String,
     val state: RouteFlowStepState,
     val stateLabel: String,
+    val dateLabel: String? = null,
 )
 
 data class RouteLifecycleActionUi(
@@ -49,12 +50,65 @@ data class RouteSyncCalloutUi(
 fun canManageRoutePhotos(selectedDate: String, today: LocalDate = LocalDate.now()): Boolean =
     runCatching { LocalDate.parse(selectedDate).isEqual(today) }.getOrDefault(false)
 
+fun routeIsActiveToday(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): Boolean {
+    val viewedDate = runCatching { LocalDate.parse(selectedDate) }.getOrNull() ?: return false
+    val loadingDate = route.routeDate?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: return false
+    val unloadingDate = route.unloadingDate
+        ?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
+        ?: loadingDate
+
+    return viewedDate == today && !today.isBefore(loadingDate) && !today.isAfter(unloadingDate)
+}
+
+fun routeUnloadingDate(route: DriverRouteDto): String? = route.unloadingDate ?: route.routeDate
+
+fun routeScheduleDateLabel(date: String?): String =
+    date
+        ?.let { runCatching { LocalDate.parse(it).format(shortDateFormatter) }.getOrNull() }
+        ?: "—"
+
+fun routeScheduleSummary(route: DriverRouteDto): String {
+    val loading = routeScheduleDateLabel(route.routeDate)
+    val unloading = routeScheduleDateLabel(routeUnloadingDate(route))
+
+    return if (route.unloadingDate == null) {
+        "Załadunek: $loading · Rozładunek: ten sam dzień"
+    } else {
+        "Załadunek: $loading · Rozładunek: $unloading"
+    }
+}
+
+fun routeTodayInstruction(
+    route: DriverRouteDto,
+    selectedDate: String,
+    today: LocalDate = LocalDate.now(),
+): String? {
+    if (!routeIsActiveToday(route, selectedDate, today)) return null
+
+    val loadingDate = route.routeDate?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: return null
+    val unloadingDate = routeUnloadingDate(route)?.let { runCatching { LocalDate.parse(it) }.getOrNull() } ?: loadingDate
+
+    return when {
+        route.status == "ZAKOŃCZONA" -> "Kurs zakończony."
+        loadingDate == unloadingDate -> "Dziś: załadunek i rozładunek."
+        today == loadingDate -> "Dziś: załadunek."
+        today == unloadingDate && route.status == "ZAPLANOWANA" -> "Dziś: rozładunek. Załadunek możesz potwierdzić dzisiaj."
+        today == unloadingDate -> "Dziś: rozładunek."
+        else -> "Kurs jest w trasie. Rozładunek: ${routeScheduleDateLabel(routeUnloadingDate(route))}."
+    }
+}
+
 fun canCompleteRouteFromDriverApp(
     route: DriverRouteDto,
     selectedDate: String,
     today: LocalDate = LocalDate.now(),
 ): Boolean =
-    canManageRoutePhotos(selectedDate, today)
+    runCatching { LocalDate.parse(selectedDate) }.getOrNull() == today
+        && routeUnloadingDate(route)?.let { runCatching { LocalDate.parse(it) }.getOrNull() } == today
         && route.status in setOf("ZAPLANOWANA", "W TRAKCIE")
 
 fun canStartRouteFromDriverApp(
@@ -62,7 +116,7 @@ fun canStartRouteFromDriverApp(
     selectedDate: String,
     today: LocalDate = LocalDate.now(),
 ): Boolean =
-    canManageRoutePhotos(selectedDate, today)
+    routeIsActiveToday(route, selectedDate, today)
         && route.status == "ZAPLANOWANA"
 
 fun canFinishRouteFromDriverApp(
@@ -70,8 +124,9 @@ fun canFinishRouteFromDriverApp(
     selectedDate: String,
     today: LocalDate = LocalDate.now(),
 ): Boolean =
-    canManageRoutePhotos(selectedDate, today)
-        && route.status == "W TRAKCIE"
+    route.status == "W TRAKCIE"
+        && runCatching { LocalDate.parse(selectedDate) }.getOrNull() == today
+        && routeUnloadingDate(route)?.let { runCatching { LocalDate.parse(it) }.getOrNull() } == today
 
 fun canSubmitRouteStageForm(weightText: String, serverPhotoCount: Int, localUploadCount: Int): Boolean {
     return routeStageSubmitBlocker(weightText, serverPhotoCount, localUploadCount) == null
@@ -116,8 +171,8 @@ fun routeLifecyclePrimaryAction(
     today: LocalDate = LocalDate.now(),
 ): RouteLifecycleActionUi? =
     when {
-        canStartRouteFromDriverApp(route, selectedDate, today) -> RouteLifecycleActionUi("Rozpocznij kurs", RouteLifecycleAction.Start)
-        canFinishRouteFromDriverApp(route, selectedDate, today) -> RouteLifecycleActionUi("Zakończ kurs", RouteLifecycleAction.Finish)
+        canStartRouteFromDriverApp(route, selectedDate, today) -> RouteLifecycleActionUi("Załaduj", RouteLifecycleAction.Start)
+        canFinishRouteFromDriverApp(route, selectedDate, today) -> RouteLifecycleActionUi("Rozładuj", RouteLifecycleAction.Finish)
         else -> null
     }
 
@@ -175,10 +230,10 @@ fun routeFlowSteps(route: DriverRouteDto, actions: List<RouteActionEntity>): Lis
     }
 
     return listOf(
-        RouteFlowStepUi("loading_photos", "Zdjęcia załadunku", loadingPhotosState, routeFlowStateLabel(loadingPhotosState)),
-        RouteFlowStepUi("loading_weight", "Waga załadunku", loadingWeightState, routeFlowStateLabel(loadingWeightState)),
+        RouteFlowStepUi("loading_photos", "Zdjęcia załadunku", loadingPhotosState, routeFlowStateLabel(loadingPhotosState), routeScheduleDateLabel(route.routeDate)),
+        RouteFlowStepUi("loading_weight", "Waga załadunku", loadingWeightState, routeFlowStateLabel(loadingWeightState), routeScheduleDateLabel(route.routeDate)),
         RouteFlowStepUi("transit", "W trasie", transitState, routeFlowStateLabel(transitState)),
-        RouteFlowStepUi("unloading", "Rozładunek", unloadingState, routeFlowStateLabel(unloadingState)),
+        RouteFlowStepUi("unloading", "Rozładunek", unloadingState, routeFlowStateLabel(unloadingState), routeScheduleDateLabel(routeUnloadingDate(route))),
     )
 }
 

app/src/main/java/pl/firmatpp/kierowca/ui/DriverViewModel.kt

@@ -96,6 +96,7 @@ data class DriverUiState(
 
     val displayRoutes: List<DriverRouteDto>
         get() = projectDriverRoutes(routes, projectionActions)
+            .sortedBy { route -> if (route.status == "ZAKOŃCZONA") 1 else 0 }
 
     val selectedRouteProjection: ProjectedDriverRoute?
         get() = selectedRoute?.let { projectDriverRoute(it, projectionActions) }
@@ -634,7 +635,12 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
     }
 
     fun uploadPhoto(uri: Uri, source: String, metadata: PhotoUploadMetadata = PhotoUploadMetadata(), stage: String = "other") {
-        val route = _state.value.selectedRoute ?: return
+        val snapshot = _state.value
+        val route = snapshot.selectedRoute ?: return
+        if (!routeIsActiveToday(route, snapshot.selectedDate)) {
+            _state.update { it.copy(error = "Zdjęcia możesz dodać tylko w zaplanowanym zakresie kursu.") }
+            return
+        }
         viewModelScope.launch {
             _state.update { it.copy(error = null) }
             runCatching { photoUploadOutbox.enqueue(route.id, uri, source, metadata, stage) }
@@ -645,7 +651,12 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
     }
 
     fun openStartRoute() {
-        val route = _state.value.selectedRoute ?: return
+        val snapshot = _state.value
+        val route = snapshot.selectedRoute ?: return
+        if (!canStartRouteFromDriverApp(route, snapshot.selectedDate)) {
+            _state.update { it.copy(error = "Załadunek nie jest dostępny poza zaplanowanym zakresem kursu.") }
+            return
+        }
         _state.update {
             it.copy(
                 screen = DriverScreen.StartRoute,
@@ -681,7 +692,12 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
     }
 
     fun openFinishRoute() {
-        val route = _state.value.selectedRoute ?: return
+        val snapshot = _state.value
+        val route = snapshot.selectedRoute ?: return
+        if (!canFinishRouteFromDriverApp(route, snapshot.selectedDate)) {
+            _state.update { it.copy(error = "Rozładunek jest dostępny w dniu zaplanowanego rozładunku.") }
+            return
+        }
         _state.update {
             it.copy(
                 screen = DriverScreen.FinishRoute,
@@ -708,6 +724,21 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
     private fun submitRouteStage(stage: String) {
         val snapshot = _state.value
         val route = snapshot.selectedRoute ?: return
+        val canSubmitStage = if (stage == "loading") {
+            canStartRouteFromDriverApp(route, snapshot.selectedDate)
+        } else {
+            canFinishRouteFromDriverApp(route, snapshot.selectedDate)
+        }
+        if (!canSubmitStage) {
+            _state.update {
+                it.copy(error = if (stage == "loading") {
+                    "Załadunek nie jest dostępny poza zaplanowanym zakresem kursu."
+                } else {
+                    "Rozładunek jest dostępny w dniu zaplanowanego rozładunku."
+                })
+            }
+            return
+        }
         val driver = snapshot.driver
         val weight = snapshot.routeStageWeightText.trim().replace(',', '.').toDoubleOrNull()
         val stagePhotos = routePhotosForStage(route.photos, stage)
@@ -880,8 +911,13 @@ class DriverViewModel(application: Application) : AndroidViewModel(application)
     }
 
     fun completeSelectedRoute() {
-        val route = _state.value.selectedRoute ?: return
-        if (_state.value.completingRoute || !_state.value.isOnline) return
+        val snapshot = _state.value
+        val route = snapshot.selectedRoute ?: return
+        if (snapshot.completingRoute || !snapshot.isOnline) return
+        if (!canCompleteRouteFromDriverApp(route, snapshot.selectedDate)) {
+            _state.update { it.copy(error = "Zakończenie kursu jest dostępne w dniu zaplanowanego rozładunku.") }
+            return
+        }
 
         viewModelScope.launch {
             _state.update { it.copy(completingRoute = true, feedback = null, error = null) }

app/src/test/java/pl/firmatpp/kierowca/ui/DriverLeaveRequestUiRulesTest.kt

@@ -64,6 +64,25 @@ class DriverLeaveRequestUiRulesTest {
         assertEquals(listOf("week", "single-day"), matching.map { it.id })
     }
 
+    @Test
+    fun findsCalendarEntriesThatOverlapSelectedRange() {
+        val entries = listOf(
+            calendarEntry(id = "starts-before", dateFrom = "2026-08-01", dateTo = "2026-08-04"),
+            calendarEntry(id = "inside", dateFrom = "2026-08-06", dateTo = "2026-08-07"),
+            calendarEntry(id = "ends-after", dateFrom = "2026-08-09", dateTo = "2026-08-12"),
+            calendarEntry(id = "before", dateFrom = "2026-07-20", dateTo = "2026-07-22"),
+            calendarEntry(id = "after", dateFrom = "2026-08-13", dateTo = "2026-08-14"),
+        )
+
+        val matching = DriverLeaveRequestUiRules.calendarEntriesForRange(
+            entries = entries,
+            dateFrom = "2026-08-03",
+            dateTo = "2026-08-10",
+        )
+
+        assertEquals(listOf("starts-before", "inside", "ends-after"), matching.map { it.id })
+    }
+
     @Test
     fun normalizesPhoneNumberIntoDialerUri() {
         assertEquals("tel:+48600700800", DriverLeaveRequestUiRules.phoneDialUri("+48 600 700 800"))

app/src/test/java/pl/firmatpp/kierowca/ui/DriverRouteProjectionTest.kt

@@ -154,6 +154,7 @@ class DriverRouteProjectionTest {
     ): DriverRouteDto =
         DriverRouteDto(
             id = "1",
+            routeDate = "2026-06-30",
             startsAt = "",
             originName = "Baza",
             destinationName = "Instalacja",

app/src/test/java/pl/firmatpp/kierowca/ui/DriverUiRulesTest.kt

@@ -39,6 +39,32 @@ class DriverUiRulesTest {
         assertFalse(canCompleteRouteFromDriverApp(route(status = "ZAPLANOWANA"), "2026-06-29", today))
     }
 
+    @Test
+    fun multiDayRouteCanLoadTodayButCanUnloadOnlyOnItsUnloadingDate() {
+        val route = route(
+            status = "ZAPLANOWANA",
+            routeDate = "2026-06-29",
+            unloadingDate = "2026-06-30",
+        )
+
+        assertTrue(canStartRouteFromDriverApp(route, "2026-06-30", today))
+        assertEquals("Załaduj", routeLifecyclePrimaryAction(route, "2026-06-30", today)?.label)
+        assertEquals("Dziś: rozładunek. Załadunek możesz potwierdzić dzisiaj.", routeTodayInstruction(route, "2026-06-30", today))
+
+        val activeRoute = route.copy(status = "W TRAKCIE")
+        assertTrue(canFinishRouteFromDriverApp(activeRoute, "2026-06-30", today))
+        assertEquals("Rozładuj", routeLifecyclePrimaryAction(activeRoute, "2026-06-30", today)?.label)
+        assertFalse(canFinishRouteFromDriverApp(activeRoute, "2026-06-29", LocalDate.parse("2026-06-29")))
+    }
+
+    @Test
+    fun routeScheduleShowsBothDispatcherDates() {
+        val route = route(routeDate = "2026-06-30", unloadingDate = "2026-07-02")
+
+        assertEquals("Załadunek: 30.06 · Rozładunek: 02.07", routeScheduleSummary(route))
+        assertEquals("Załadunek: 30.06 · Rozładunek: ten sam dzień", routeScheduleSummary(route.copy(unloadingDate = null)))
+    }
+
     @Test
     fun showsLiveRouteDayUpdateOnlyForViewedDate() {
         assertTrue(shouldShowRouteDayLiveUpdate(viewedDate = "2026-03-12", hintDate = "2026-03-12"))
@@ -300,7 +326,7 @@ class DriverUiRulesTest {
         assertEquals(RouteFlowStepState.Todo, steps[1].state)
         assertEquals(RouteFlowStepState.Todo, steps[2].state)
         assertEquals(RouteFlowStepState.Todo, steps[3].state)
-        assertEquals("Rozpocznij kurs", action?.label)
+        assertEquals("Załaduj", action?.label)
         assertEquals(RouteLifecycleAction.Start, action?.action)
     }
 
@@ -327,7 +353,7 @@ class DriverUiRulesTest {
         assertEquals(RouteFlowStepState.Confirmed, steps[1].state)
         assertEquals(RouteFlowStepState.LocalComplete, steps[2].state)
         assertEquals(RouteFlowStepState.Todo, steps[3].state)
-        assertEquals("Zakończ kurs", action?.label)
+        assertEquals("Rozładuj", action?.label)
         assertEquals(RouteLifecycleAction.Finish, action?.action)
     }
 
@@ -400,13 +426,17 @@ class DriverUiRulesTest {
     }
 
     private fun route(
-        status: String,
+        status: String = "ZAPLANOWANA",
         loadingWeight: Double? = null,
         unloadingWeight: Double? = null,
         photos: List<RoutePhotoDto> = emptyList(),
+        routeDate: String? = "2026-06-30",
+        unloadingDate: String? = null,
     ): DriverRouteDto =
         DriverRouteDto(
             id = "1",
+            routeDate = routeDate,
+            unloadingDate = unloadingDate,
             startsAt = "",
             originName = "Baza",
             destinationName = "Instalacja",

app/src/test/java/pl/firmatpp/kierowca/ui/DriverUiStateTest.kt

@@ -70,6 +70,19 @@ class DriverUiStateTest {
         assertEquals(12.5, state.displaySelectedRoute?.loadingWeight)
     }
 
+    @Test
+    fun displayRoutesMovesCompletedRoutesBelowActiveDispatcherOrder() {
+        val state = DriverUiState(
+            routes = listOf(
+                route(id = "completed", status = "ZAKOŃCZONA"),
+                route(id = "planned", status = "ZAPLANOWANA"),
+                route(id = "active", status = "W TRAKCIE"),
+            ),
+        )
+
+        assertEquals(listOf("planned", "active", "completed"), state.displayRoutes.map { it.id })
+    }
+
     private fun leaveRequest(id: String, status: String): DriverLeaveRequestDto =
         DriverLeaveRequestDto(
             id = id,
@@ -79,9 +92,10 @@ class DriverUiStateTest {
             status = status,
         )
 
-    private fun route(status: String): DriverRouteDto =
+    private fun route(id: String = "1", status: String): DriverRouteDto =
         DriverRouteDto(
-            id = "1",
+            id = id,
+            routeDate = "2026-06-30",
             startsAt = "",
             originName = "Baza",
             destinationName = "Instalacja",