feat: validate badge printer availability

Author: kkostov

pretixscan/composeApp/src/commonMain/composeResources/values/strings.xml

@@ -217,4 +217,11 @@
     <string name="settings_label_badge_layout">Orientation</string>
     <string name="sync_completed">Sync completed successfully</string>
     <string name="sync_error">Sync completed with errors</string>
+    <string name="badge_printing_not_available">Badge printing unavailable</string>
+    <string name="badge_printing_not_possible_no_available_printer">There are no available printers on the system.
+        Please, configure at least one printer and try again.
+    </string>
+    <string name="badge_printing_selected_printer_not_available">The selected printer is currently unavailable. Please
+        check that the device is online and connected to the system.
+    </string>
 </resources>

…tlin/eu/pretix/scan/setup/ErrorDialog.kt …/eu/pretix/desktop/app/ui/ErrorDialog.ktpretixscan/composeApp/src/commonMain/kotlin/eu/pretix/scan/setup/ErrorDialog.kt renamed to pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/desktop/app/ui/ErrorDialog.kt pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/scan/setup/ErrorDialog.kt renamed to pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/desktop/app/ui/ErrorDialog.kt

@@ -1,4 +1,4 @@
-package eu.pretix.scan.setup
+package eu.pretix.desktop.app.ui
 
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape

pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/scan/settings/presentation/SettingsScreen.kt

@@ -38,6 +38,7 @@ fun SettingsScreen(
 
     val viewModel = koinViewModel<SettingsViewModel>()
     val form by viewModel.form.collectAsState()
+    val uiState by viewModel.uiState.collectAsState()
     val state = rememberLazyListState()
 
     LaunchedEffect(Unit) {
@@ -298,6 +299,29 @@ fun SettingsScreen(
             }
         }
     }
+
+    when (uiState) {
+        is SettingsUiState.Start -> {}
+        is SettingsUiState.ErrorNoAvailablePrinters -> {
+            ErrorDialog(
+                title = stringResource(Res.string.badge_printing_not_available),
+                message = stringResource(Res.string.badge_printing_not_possible_no_available_printer),
+                onDismiss = {
+                    viewModel.dismissError()
+                }
+            )
+        }
+
+        is SettingsUiState.ErrorSelectedPrinterNotAvailable -> {
+            ErrorDialog(
+                title = stringResource(Res.string.badge_printing_not_available),
+                message = stringResource(Res.string.badge_printing_selected_printer_not_available),
+                onDismiss = {
+                    viewModel.dismissError()
+                }
+            )
+        }
+    }
 }
 
 @Composable

pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/scan/settings/presentation/SettingsUiState.kt

@@ -0,0 +1,7 @@
+package eu.pretix.scan.settings.presentation
+
+sealed class SettingsUiState<out T> {
+    object Start : SettingsUiState<Nothing>()
+    object ErrorNoAvailablePrinters : SettingsUiState<Nothing>()
+    object ErrorSelectedPrinterNotAvailable : SettingsUiState<Nothing>()
+}

pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/scan/settings/presentation/SettingsViewModel.kt

@@ -10,7 +10,9 @@ import eu.pretix.desktop.cache.Version
 import eu.pretix.scan.settings.data.ConfigurableSettings
 import eu.pretix.scan.settings.data.PrinterSource
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 
 
 class SettingsViewModel(
@@ -23,7 +25,15 @@ class SettingsViewModel(
     private val _form = MutableStateFlow(ConfigurableSettings())
     val form = _form.asStateFlow()
 
+    private val _uiState = MutableStateFlow<SettingsUiState<String>>(SettingsUiState.Start)
+    val uiState: StateFlow<SettingsUiState<String>> = _uiState
+
+    fun dismissError() {
+        _uiState.update { SettingsUiState.Start }
+    }
+
     suspend fun loadSettings() {
+        val badgePrinterWasSelected = appConfig.printBadges && appConfig.badgePrinterName != null
         _form.value = _form.value.copy(
             version = "${Version.version} (${Version.versionCode})",
             printers = printerSource.listPrinters(),
@@ -37,6 +47,11 @@ class SettingsViewModel(
             uiReduceMotion = appConfig.uiReduceMotion,
             uiHideNames = appConfig.uiHideNames,
         )
+
+        // check if printer setup is correct
+        if (_form.value.printBadges && badgePrinterWasSelected && _form.value.badgePrinter == null) {
+            _uiState.update { SettingsUiState.ErrorSelectedPrinterNotAvailable }
+        }
     }
 
     suspend fun setBadgePrinter(option: SelectableValue?) {
@@ -56,8 +71,27 @@ class SettingsViewModel(
     }
 
     suspend fun setPrintBadges(value: Boolean) {
-        appConfig.printBadges = value
-        loadSettings()
+        if (value) {
+            // turning badge printing on, check that we have at least one selectable printer
+            loadSettings()
+            val firstPrinter = _form.value.printers.firstOrNull()
+            if (firstPrinter == null) {
+                // sorry
+                appConfig.printBadges = false
+                loadSettings()
+                _uiState.update { SettingsUiState.ErrorNoAvailablePrinters }
+                return
+            }
+
+            // turn printing on, preselect the first printer
+            appConfig.printBadges = true
+            setBadgePrinter(firstPrinter)
+
+        } else {
+            // turning printing off
+            appConfig.printBadges = false
+            loadSettings()
+        }
     }
 
     suspend fun setSyncAuto(value: Boolean) {

pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/scan/tickets/presentation/TicketHandlingDialog.kt

@@ -14,13 +14,17 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.key.*
 import androidx.compose.ui.unit.dp
 import com.composables.core.*
+import eu.pretix.desktop.app.ui.ErrorDialog
 import eu.pretix.scan.tickets.data.ResultState
 import eu.pretix.scan.tickets.data.isAutoDismissible
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import org.jetbrains.compose.resources.stringResource
 import org.jetbrains.compose.ui.tooling.preview.Preview
 import org.koin.compose.viewmodel.koinViewModel
+import pretixscan.composeapp.generated.resources.Res
+import pretixscan.composeapp.generated.resources.badge_printing_not_available
 import java.util.logging.Logger
 
 private val log = Logger.getLogger("TicketHandlingDialog")
@@ -36,6 +40,7 @@ fun TicketHandlingDialog(
 
     val viewModel = koinViewModel<TicketHandlingDialogViewModel>()
     val uiState by viewModel.uiState.collectAsState()
+    val localTicketHandlingErrors by viewModel.localTicketHandlingErrors.collectAsState()
     val coroutineScope = rememberCoroutineScope()
     val dialogState = rememberDialogState(initiallyVisible = true)
     var remainingTimeProgress by remember { mutableStateOf(1.0f) }
@@ -169,5 +174,19 @@ fun TicketHandlingDialog(
             }
         }
     }
+
+
+    when (localTicketHandlingErrors) {
+        is TicketHandlingErrors.None -> {}
+        is TicketHandlingErrors.Error -> {
+            ErrorDialog(
+                title = stringResource(Res.string.badge_printing_not_available),
+                message = (localTicketHandlingErrors as TicketHandlingErrors.Error).exception,
+                onDismiss = {
+                    viewModel.dismissError()
+                }
+            )
+        }
+    }
 }
 

pretixscan/composeApp/src/commonMain/kotlin/eu/pretix/scan/tickets/presentation/TicketHandlingDialogViewModel.kt

@@ -7,13 +7,14 @@ import eu.pretix.scan.tickets.data.ResultState
 import eu.pretix.scan.tickets.data.ResultStateData
 import eu.pretix.scan.tickets.data.TicketCodeHandler
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import java.util.logging.Logger
 
 class TicketHandlingDialogViewModel(
     private val tickerCodeHandler: TicketCodeHandler,
-    private val badgeFactory: BadgeFactory
+    private val badgeFactory: BadgeFactory,
 ) : ViewModel() {
 
     private val log = Logger.getLogger("TicketHandlingDialogViewModel")
@@ -25,6 +26,13 @@ class TicketHandlingDialogViewModel(
         _uiState.value = ResultStateData(resultState = ResultState.EMPTY)
     }
 
+    private val _localTicketHandlingErrors = MutableStateFlow<TicketHandlingErrors<String>>(TicketHandlingErrors.None)
+    val localTicketHandlingErrors: StateFlow<TicketHandlingErrors<String>> = _localTicketHandlingErrors
+
+    fun dismissError() {
+        _localTicketHandlingErrors.update { TicketHandlingErrors.None }
+    }
+
     suspend fun handleTicket(secret: String?, answers: List<Answer>? = null, ignoreUnpaid: Boolean = false) {
         log.info("Handling ticket")
         _uiState.update {
@@ -41,7 +49,7 @@ class TicketHandlingDialogViewModel(
     }
 
     suspend fun printBadges() {
-        log.info("Printing badges")
+        log.info("User requested to print a badge")
         val layout = _uiState.value.badgeLayout
         val position = _uiState.value.position
         if (layout == null) {
@@ -54,8 +62,16 @@ class TicketHandlingDialogViewModel(
             return
         }
 
-
-        badgeFactory.setup()
-        badgeFactory.printBadges(layout, position)
+        try {
+            badgeFactory.setup()
+            badgeFactory.printBadges(layout, position)
+        } catch (e: Exception) {
+            _localTicketHandlingErrors.update { TicketHandlingErrors.Error(e.localizedMessage) }
+        }
     }
+}
+
+sealed class TicketHandlingErrors<out T> {
+    object None : TicketHandlingErrors<Nothing>()
+    data class Error(val exception: String) : TicketHandlingErrors<Nothing>()
 }