11. Caso de estudio: el cliente Kotlin de la aplicación RdvMedecins
11.1. El problema
La aplicación [RdvMedecins] permite programar citas en un consultorio médico. El curso de [NestJS] la desarrolló como una aplicación HTML, en la que el servidor generaba las páginas; los cursos de [Vue.js], [Angular] y [React] desarrollaron clientes web para ella, y el curso de [Flutter] creó un cliente móvil, que genera las MISMAS pantallas a partir de los datos JSON proporcionados por el servidor descrito en el capítulo “El servidor RdvMedecins : una caja negra”. Este capítulo describe cómo escribir un cliente [Android] nativo, en [Kotlin] y [Jetpack Compose].
El cliente debe ofrecer todo lo que ofrecían los demás:
- una pantalla de inicio de sesión, protegida por un CAPTCHA, con la opción de crear una cuenta de paciente;
- la agenda de un médico para un día determinado, con reserva de citas (ventana de selección de paciente) y cancelación;
- para el administrador, la gestión de médicos y clientes (lista, alta, edición, eliminación);
- para el paciente, un panel personal (que muestra las citas futuras, que puede cancelar) y la gestión de la cuenta;
- dos idiomas: francés e inglés;
- las mismas pantallas que los clientes web ([/login], [/schedule], [/doctors], [/my-area]...), que aquí se convierten en pantallas de navegación por RUTAS.
Una aplicación móvil añade sus propios requisitos: una pantalla estrecha (sin tablas de cinco columnas), un teclado que oculta la mitad de la pantalla, un botón Atrás, la rotación de la pantalla y el cambio de idioma que afectan a la actividad (la RECREAN), un administrador de contraseñas y la ausencia de un navegador que almacene la cookie del token.
11.2. Instalación y ejecución
El servidor JSON debe estar instalado y en ejecución (consulte el capítulo “El servidor RdvMedecins: una caja negra”). El modo de prueba del CAPTCHA no es necesario: puede dejar [CAPTCHA_TEST] vacío en el archivo [.env] del servidor.
En [Android Studio], [File / Open] abre la carpeta [rdvmedecins_kotlin]; [Gradle] descarga las bibliotecas (la primera vez, esto toma unos minutos). Una vez que el emulador está en ejecución, una ventana de comandos conecta su puerto 8080 con el de la computadora:
| adb reverse tcp:8080 tcp:8080
|
luego el botón [Run] instala e inicia la aplicación. También puede hacer todo en una ventana de comandos abierta en la carpeta [rdvmedecins_kotlin]:
| gradlew installDebug
gradlew installDebug -Pserver=http://10.0.2.2:8080
gradlew installDebug -Pserver=http://192.168.1.20:8080
|
- la primera línea compila e instala la aplicación en el dispositivo conectado (emulador o teléfono), que se conecta al servidor en la dirección [http://localhost:8080] mediante [adb reverse];
- la segunda, para el emulador, sin [adb reverse]: el emulador ve la computadora en la dirección [10.0.2.2];
- la tercera, para un teléfono real conectado por Wi-Fi a la misma red que la computadora: se proporciona la dirección de la computadora en esa red ([ipconfig] en [Windows]); el firewall de [Windows] debe permitir las conexiones entrantes en el puerto 8080. Un teléfono conectado por USB (con la “depuración por USB” habilitada en sus opciones de desarrollador) también puede usar [adb reverse].
Las cuentas de demostración se enumeran en la pantalla de inicio de sesión (contraseña = nombre de usuario).
11.3. Uso de la aplicación
Las capturas de pantalla de esta sección provienen de un emulador de Pixel 8 (1080 × 2400 píxeles, 412 × 915 dp). Se generaron automáticamente mediante una prueba instrumentada ([app/src/androidTest/.../CaseStudyCaptures.kt], consulte los apéndices) que navega por la aplicación como lo haría un usuario.
11.3.1. La pantalla de inicio de sesión
La pantalla de inicio de sesión; contraseña incorrecta: el mensaje aparece en la parte inferior de la pantalla y se muestra una nueva imagen (cada imagen se usa una sola vez):


11.3.2. La agenda, vista por el administrador y los médicos
Con la sesión iniciada como [admin], se llega a la agenda. Seleccione un médico y un día (el día, desde un calendario) y luego “View schedule”:



“Book” abre la ventana de reserva, con una ruta de navegación mostrada sobre la agenda; se guarda la cita; “Cancel” solicita confirmación:



Un médico ([pelissier]) es dirigido directamente a SU agenda diaria:

11.3.3. El área del paciente
Un paciente ([martin]) accede a “My area”. En una agenda, reserva una cita para sí mismo sin seleccionar un paciente:



Su cita aparece bajo su nombre; el botón “Book” ya no está disponible (solo una cita futura) y un mensaje explica el motivo. Su cuenta muestra la cita. “Manage my account”: cualquier cambio requiere la contraseña actual; los errores provienen del servidor:



El menú de un paciente no tiene una entrada “Doctors”. Si abriera esta pantalla de todos modos (mediante un enlace), la navegación mostraría una página de error 403 (consulte [navigation/Navigation.kt]).
11.3.4. Gestión de médicos y clientes
La lista de médicos; un alta completada incorrectamente; un alta exitosa:



Un registro duplicado; una eliminación exitosa:


11.3.5. Creación de una cuenta
En la pantalla de inicio de sesión, ingrese el CAPTCHA y luego toque “Create a patient account”. El servidor rechaza el formulario; una vez creada la cuenta, se vuelve a la pantalla de inicio de sesión, donde los datos de acceso ya están rellenados:


11.3.6. En francés, y luego en una pantalla grande
El menú FR / EN de la barra superior cambia el idioma de la aplicación: la actividad se recrea y TODO se vuelve a traducir, incluidos la agenda y las fechas. En una pantalla ancha (una tableta o un teléfono sostenido en horizontal), el menú permanece visible a la izquierda:


11.3.7. Sesión vencida
Si el token vence (o si se elimina la cookie), la siguiente solicitud devuelve un 401; la aplicación redirige a la pantalla de inicio de sesión. Después de iniciar sesión, redirige al usuario de vuelta a la pantalla que quería ver:

11.4. Arquitectura del cliente
| rdvmedecins_kotlin/
├── settings.gradle.kts, build.gradle.kts the Gradle project
├── gradle/libs.versions.toml the versions of the libraries
└── app/
├── build.gradle.kts the module of the application
└── src/
├── androidTest/ the test that makes the screenshots
└── main/
├── AndroidManifest.xml
├── assets/i18n/ the dictionaries fr.json, en.json
├── res/ icon, name, theme, languages
└── java/fr/stahe/rdvmedecins/
├── RdvMedecinsApplication.kt the shared objects
├── MainActivity.kt the single activity
├── Config.kt the address of the server
├── Formatting.kt hours and days
├── api/ the API access layer
├── state/ session, messages, cache
├── i18n/ the languages
├── navigation/ the screens, their routes, their access rights
├── widgets/ the layout and the reusable components
└── pages/ the screens
|
Esta es la arquitectura recomendada por la guía de [Android] (“Guide to App Architecture”), simplificada de la siguiente manera:
- una capa de datos ([api/]): la única capa que conoce [OkHttp], los objetos URL y el objeto JSON;
- una capa de estado ([state/]): objetos cuyas propiedades son estados de [Compose], creados una sola vez por el objeto [Application] y proporcionados a todas las pantallas ([LocalDependencies]);
- una capa de interfaz ([pages/], [widgets/]): funciones [@Composable], que muestran el estado y transmiten las acciones del usuario.
La siguiente tabla compara la aplicación HTML del curso de [NestJS], el cliente [Flutter] y este cliente:
Aplicación HTML (NestJS) | Cliente Flutter | Cliente Kotlin |
El servidor renderiza cada página ([res.render]) | Los widgets renderizan las pantallas | Las funciones [@Composable] generan las pantallas |
[views/layout.hbs] y sus vistas parciales | [layout.dart] (un [ShellRoute]) | [AppLayout.kt], alrededor de [NavHost] |
las rutas del controlador | [go_router] | [navigation-compose], rutas [@Serializable] |
[JwtAuthGuard], [RolesGuard] | La función [redirect] del enrutador | [Protected] y un efecto que observa la sesión |
la cookie del token, almacenada por el navegador | un cliente HTTP que gestiona las cookies | el [CookieJar] de [OkHttp] |
Mensaje flash en una cookie | un [ChangeNotifier], [Messages] | una clase con estado de [Compose], [Messages] |
Diccionarios leídos por el servidor | [Translations] (JSON) | [Translations] (los MISMOS archivos JSON) |
idioma almacenado en una cookie | en [shared_preferences] | por [Android] ([setApplicationLocales]) |
datos que ya se leyeron | [Cache] (unas pocas líneas) | [Cache] (unas pocas líneas, a partir de [Deferred]) |
Formulario rechazado: el servidor vuelve a cargar la página | respuesta 400/409, errores debajo de los campos | igual |
A continuación se muestran todos los archivos del cliente. Están ampliamente comentados; sus comentarios forman parte del curso.
11.5. Configuración del proyecto
11.5.1. settings.gradle.kts, build.gradle.kts
| // =========================================================================
// settings.gradle.kts - la configuración GLOBAL del proyecto Gradle
// (generado por Android Studio; solo se cambió rootProject.name)
// =========================================================================
// dónde busca Gradle sus PLUGINS (el plugin de Android, el plugin de Compose...)
pluginManagement {
repositories {
google {
content {
includeGroupByRegex("com\\.android.*")
includeGroupByRegex("com\\.google.*")
includeGroupByRegex("androidx.*")
}
}
mavenCentral()
gradlePluginPortal()
}
}
plugins {
id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
}
// dónde busca Gradle las BIBLIOTECAS: google() para AndroidX y Compose,
// mavenCentral() para OkHttp, kotlinx.serialization, AndroidSVG
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
google()
mavenCentral()
}
}
rootProject.name = "rdvmedecins_kotlin"
// un solo módulo: la aplicación, en la carpeta app/
include(":app")
// =========================================================================
// build.gradle.kts (raíz) - declara los plugins de Gradle usados por los
// módulos del proyecto, sin aplicarlos aquí ("apply false"): es
// app/build.gradle.kts quien los aplica.
// =========================================================================
plugins {
alias(libs.plugins.android.application) apply false
alias(libs.plugins.kotlin.compose) apply false
alias(libs.plugins.kotlin.serialization) apply false
}
|
Los archivos de los ejemplos (consulte el ejemplo 01).
11.5.2. gradle/libs.versions.toml
| # =========================================================================
# gradle/libs.versions.toml - el "catálogo de versiones" del proyecto
# -------------------------------------------------------------------------
# TODAS las versiones de los plugins y de las bibliotecas, en un solo lugar.
# Los archivos build.gradle.kts hacen referencia a ellas por su nombre
# (libs.okhttp, libs.plugins.kotlin.compose...). Es el equivalente de la
# sección dependencies del pubspec.yaml de Flutter.
# =========================================================================
[versions]
agp = "9.4.1"
kotlin = "2.2.10"
coreKtx = "1.17.0"
lifecycle = "2.9.4"
activityCompose = "1.11.0"
composeBom = "2026.02.01"
appcompat = "1.7.1"
navigation = "2.9.5"
okhttp = "4.12.0"
kotlinxSerializationJson = "1.9.0"
androidsvg = "1.4"
junit = "4.13.2"
junitVersion = "1.3.0"
espressoCore = "3.7.0"
testRunner = "1.7.0"
[libraries]
# — generado por Android Studio (plantilla "Empty Activity") —
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "testRunner" }
# añadido para RdvMedecins
# los íconos básicos de Material (Add, Delete, Search...)
androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
# el ciclo de vida de la actividad visto desde Compose
androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" }
# viewModel() en una función @Composable
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
# el idioma PROPIO de la aplicación
androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
# el enrutador
androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation" }
# el cliente HTTP
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
# (de)serialización JSON
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
# dibujar una imagen SVG (el captcha)
androidsvg = { group = "com.caverock", name = "androidsvg-aar", version.ref = "androidsvg" }
[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
# genera el código de (de)serialización de las clases @Serializable
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
|
Las bibliotecas de los ejemplos, excepto [DataStore]: el idioma lo almacena [Android] mismo, y el token se almacena en el almacén de cookies.
11.5.3. app/build.gradle.kts
| // =========================================================================
// app/build.gradle.kts - la configuración del módulo "app": el cliente
// Android de RdvMedecins. Generado por Android Studio (plantilla "Empty
// Activity"), y luego completado (líneas marcadas "added").
// =========================================================================
plugins {
alias(libs.plugins.android.application)
alias(libs.plugins.kotlin.compose)
// agregado: el plugin kotlinx.serialization (clases @Serializable)
alias(libs.plugins.kotlin.serialization)
}
android {
namespace = "fr.stahe.rdvmedecins"
compileSdk {
version = release(37)
}
defaultConfig {
applicationId = "fr.stahe.rdvmedecins"
minSdk = 26
targetSdk = 37
versionCode = 1
versionName = "1.0"
// añadido: la dirección del servidor JSON, se puede cambiar al compilar:
// gradlew installDebug -Pserver=http://192.168.1.20:8080
val server = providers.gradleProperty("server").getOrElse("http://localhost:8080")
buildConfigField("String", "SERVER_URL", "\"$server\"")
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
optimization {
enable = false
}
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
buildFeatures {
compose = true
// agregado: la clase BuildConfig (BuildConfig.SERVER_URL)
buildConfig = true
}
}
dependencies {
implementation(platform(libs.androidx.compose.bom))
implementation(libs.androidx.activity.compose)
implementation(libs.androidx.compose.material3)
implementation(libs.androidx.compose.ui)
implementation(libs.androidx.compose.ui.graphics)
implementation(libs.androidx.compose.ui.tooling.preview)
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx)
// añadido para RdvMedecins
implementation(libs.androidx.compose.material.icons.core)
implementation(libs.androidx.lifecycle.runtime.compose)
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.appcompat)
implementation(libs.androidx.navigation.compose)
implementation(libs.okhttp)
implementation(libs.kotlinx.serialization.json)
implementation(libs.androidsvg)
// las pruebas: tomar las capturas de pantalla del curso (carpeta androidTest)
testImplementation(libs.junit)
androidTestImplementation(platform(libs.androidx.compose.bom))
androidTestImplementation(libs.androidx.compose.ui.test.junit4)
androidTestImplementation(libs.androidx.espresso.core)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.test.runner)
debugImplementation(libs.androidx.compose.ui.test.manifest)
debugImplementation(libs.androidx.compose.ui.tooling)
}
|
El de los ejemplos, con un ID de aplicación diferente ([fr.stahe.rdvmedecins]): ambas aplicaciones se pueden instalar una junto a la otra. El bloque [buildTypes] describe la versión de PRODUCCIÓN (consulte el capítulo “Despliegue”).
11.5.4. AndroidManifest.xml
| <?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
AndroidManifest.xml - la "cédula de identidad" de la aplicación
===================================================================== -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<!-- acceso a la red (el servidor JSON) -->
<uses-permission android:name="android.permission.INTERNET" />
<!-- android:name: la clase Application (RdvMedecinsApplication.kt).
usesCleartextTraffic: el HTTP "en claro" del servidor de desarrollo
(debe eliminarse para un servidor de producción en https, ver Despliegue).
localeConfig: los idiomas que ofrece la aplicación -->
<application
android:name=".RdvMedecinsApplication"
android:allowBackup="true"
android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:localeConfig="@xml/locales_config"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.RdvMedecins"
android:usesCleartextTraffic="true"
tools:targetApi="33">
<!-- la única actividad. windowSoftInputMode="adjustResize": el
teclado reduce la pantalla en lugar de ocultarla -->
<activity
android:name=".MainActivity"
android:exported="true"
android:windowSoftInputMode="adjustResize">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<!-- antes de Android 13: AppCompat recuerda el idioma elegido -->
<service
android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
android:enabled="false"
android:exported="false">
<meta-data
android:name="autoStoreLocales"
android:value="true" />
</service>
</application>
</manifest>
|
- una sola actividad, [MainActivity]: todas las pantallas son funciones [@Composable];
- [windowSoftInputMode="adjustResize"]: cuando aparece el teclado, la pantalla se reduce (en lugar de quedar oculta por el teclado);
- [android:localeConfig] y el servicio de [AppCompat]: el idioma específico de la aplicación (consulte el ejemplo 21).
11.5.5. Recursos
| <?xml version="1.0" encoding="utf-8"?>
<!-- el nombre de la aplicación (bajo su ícono). Los textos de la interfaz,
por su parte, están en los diccionarios assets/i18n/fr.json y en.json -->
<resources>
<string name="app_name">RdvMedecins</string>
</resources>
<?xml version="1.0" encoding="utf-8"?>
<resources>
<!-- el tema "Android", visible solo durante el inicio; un
tema AppCompat, requerido por AppCompatActivity (ver MainActivity.kt) -->
<style name="Theme.RdvMedecins" parent="Theme.AppCompat.DayNight.NoActionBar" />
</resources>
<?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
res/xml/locales_config.xml - los idiomas de la aplicación (ejemplo 21)
............................................................................
Declarado en AndroidManifest.xml (android:localeConfig). Desde
Android 13, el usuario también puede elegir el idioma de CADA
aplicación en los ajustes del teléfono: Ajustes > Sistema >
Idiomas > Idiomas de las aplicaciones.
===================================================================== -->
<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
<locale android:name="fr" />
<locale android:name="en" />
</locale-config>
|
Los textos de la aplicación NO se incluyen allí (solo está presente el nombre de la aplicación): están en los diccionarios JSON, [assets/i18n/fr.json] y [en.json], y en los diccionarios de los clientes [Vue.js], [Angular], [React], y [Flutter]. Un extracto:
| {
"APP": {
"TITLE": "RdvMedecins",
"LOGOUT": "Se déconnecter",
"MENU_SCHEDULE": "Agenda",
"MENU_DOCTORS": "Médecins",
"MENU_PATIENTS": "Clients",
"MENU_MY_AREA": "Mon espace",
"LOADING": "Chargement...",
"LANGUAGE": "Langue",
"MENU_ACCOUNT": "Mon compte",
"CONNECTED_AS": "Connecté : {{name}}",
"RETRY": "Réessayer"
},
"LOGIN": {
"TITLE": "Connexion",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Mot de passe",
"SUBMIT": "Se connecter",
"ERROR": "Login ou mot de passe incorrect.",
"DEMO_ACCOUNTS": "Comptes de démonstration (mot de passe = login) :",
"DEMO_ADMIN": "rôle ADMIN : rendez-vous + gestion des médecins et des clients",
"DEMO_DOCTOR": "rôle DOCTOR : prise et annulation de rendez-vous",
"DEMO_USER": "rôle USER (patients) : réservation pour eux-mêmes, gestion de leur compte",
"CREATE_ACCOUNT": "Créer un compte client",
"CREATE_ACCOUNT_HELP": "Pour créer un compte, recopiez d'abord les caractères de l'image."
},
"DOCTOR_DAY_PICKER": {
"DOCTOR_LABEL": "Médecin",
"CHOOSE_DOCTOR": "-- choisir un médecin --",
"DAY_LABEL": "Jour",
"VIEW_SCHEDULE": "Voir l'agenda",
"CHOOSE_DAY": "Choisir le jour"
},
"SCHEDULE": {
"PAGE_TITLE": "Agenda",
"TITLE_PREFIX": "Agenda du",
"COLUMN_SLOT": "Créneau",
"COLUMN_STATUS": "Statut",
"FREE": "Libre",
|
11.6. Inicio de la aplicación
11.6.1. Config.kt
| // =========================================================================
// Config.kt - ¿DÓNDE está el servidor JSON?
// -------------------------------------------------------------------------
// Una aplicación móvil no tiene "origen": hay que darle la dirección completa
// del servidor (ver ejemplo 22 y common/Config.kt de los ejemplos):
// - por defecto http://localhost:8080, con el comando
// adb reverse tcp:8080 tcp:8080
// que conecta el puerto 8080 del teléfono (o del emulador) con el de la
// computadora;
// - o bien otra dirección, definida al compilar:
// gradlew installDebug -Pserver=http://10.0.2.2:8080 (emulador)
// gradlew installDebug -Pserver=http://192.168.1.20:8080 (teléfono en Wi-Fi)
// =========================================================================
package fr.stahe.rdvmedecins
object Config {
val serverUrl: String = BuildConfig.SERVER_URL
}
|
La dirección del servidor, establecida en tiempo de compilación (consulte el ejemplo 22).
11.6.2. RdvMedecinsApplication.kt
| // =========================================================================
// RdvMedecinsApplication.kt - los objetos compartidos por toda la aplicación
// -------------------------------------------------------------------------
// Android crea UN objeto Application al iniciar, antes de cualquier actividad, y
// lo mantiene hasta que la aplicación se detiene. Allí construimos, una vez
// por todas, los objetos compartidos por todas las pantallas:
// - el cliente HTTP (y su cookie jar), la capa de acceso a la API;
// - la sesión (¿quién ha iniciado sesión?), los mensajes, el caché de datos.
// Así sobreviven a la recreación de la actividad (rotación, cambio
// de idioma). Las pantallas los obtienen mediante LocalDependencies (ver
// MainActivity.kt): es una "inyección de dependencias" hecha a mano.
// Dos mecanismos conectan estos objetos entre sí:
// 1. la respuesta 401 a una solicitud protegida (sesión expirada): se olvida
// al usuario y se prepara el mensaje; la navegación, que observa
// la sesión, vuelve entonces a la pantalla de inicio de sesión;
// 2. un cambio de usuario: los datos leídos para el usuario anterior
// ya no sirven, se vacía el caché.
// =========================================================================
package fr.stahe.rdvmedecins
import android.app.Application
import androidx.compose.runtime.snapshotFlow
import androidx.compose.runtime.staticCompositionLocalOf
import fr.stahe.rdvmedecins.api.ApiClient
import fr.stahe.rdvmedecins.api.RdvMedecinsApi
import fr.stahe.rdvmedecins.api.createHttpClient
import fr.stahe.rdvmedecins.state.Cache
import fr.stahe.rdvmedecins.state.Messages
import fr.stahe.rdvmedecins.state.Session
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch
class RdvMedecinsApplication : Application() {
// un ámbito de corrutinas que vive tanto como la aplicación
val scope = MainScope()
lateinit var api: RdvMedecinsApi
private set
lateinit var session: Session
private set
val messages = Messages()
val cache = Cache(scope)
override fun onCreate() {
super.onCreate()
val client = ApiClient(createHttpClient(this))
api = RdvMedecinsApi(client)
session = Session(api)
// 1. la sesión expirada
client.onSessionExpired = {
session.forget()
messages.flash("ERRORS.SESSION_EXPIRED", success = false)
}
// 2. el usuario cambia: snapshotFlow convierte un estado de Compose en un Flow
scope.launch {
snapshotFlow { session.user }.collect { cache.clear() }
}
}
}
// el objeto Application, provisto a todas las pantallas
val LocalDependencies = staticCompositionLocalOf<RdvMedecinsApplication> { error("no dependencies provided") }
|
- Líneas 35–41: objetos compartidos, creados una sola vez. [lateinit var]: una propiedad no [null], inicializada más tarde (en [onCreate]); [MainScope()]: un ámbito de corrutinas que vive tanto como la aplicación;
- líneas 49–51: la sesión venció: la función confiada al cliente de la API (que no sabe nada más) olvida al usuario y prepara el mensaje;
- línea 55: [snapshotFlow] transforma un estado de [Compose] en un [Flow] de estados (consulte el ejemplo 19): cada vez que cambia el usuario, se borra la caché;
- línea 61: el objeto [Application], proporcionado a todas las pantallas mediante un [CompositionLocal] (consulte el ejemplo 14): una “inyección de dependencias” programada a mano.
11.6.3. MainActivity.kt
| // =========================================================================
// MainActivity.kt - la única actividad de la aplicación
// -------------------------------------------------------------------------
// Todas las pantallas son funciones @Composable, mostradas por el NavHost
// (ver navigation/Navigation.kt) en ESTA actividad. Ella provee a todas
// las pantallas (CompositionLocalProvider):
// - los objetos compartidos de la aplicación (LocalDependencies);
// - las traducciones del idioma actual (LocalTranslations).
// Es una AppCompatActivity: sabe aplicar el idioma elegido por
// el usuario (ver ejemplo 21), incluso antes de Android 13.
// =========================================================================
package fr.stahe.rdvmedecins
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.graphics.Color
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.rememberTranslations
import fr.stahe.rdvmedecins.navigation.Navigation
// los colores: el azul de los otros clientes de RdvMedecins (Bootstrap)
private val colors = lightColorScheme(
primary = Color(0xFF0D6EFD),
onPrimary = Color.White,
primaryContainer = Color(0xFFD8E2FF),
onPrimaryContainer = Color(0xFF001A41),
secondaryContainer = Color(0xFFDAE2F9),
onSecondaryContainer = Color(0xFF131C2B),
surface = Color(0xFFFAF9FD),
)
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
val dependencies = application as RdvMedecinsApplication
setContent {
MaterialTheme(colorScheme = colors) {
CompositionLocalProvider(
LocalDependencies provides dependencies,
LocalTranslations provides rememberTranslations(),
) {
Navigation()
}
}
}
}
}
|
- líneas 27–34: los colores del tema, el azul que usan otros clientes;
- líneas 37–48: una [AppCompatActivity] (el idioma, consulte el ejemplo 21), que proporciona los objetos compartidos y las traducciones a todas las pantallas y luego muestra la navegación.
| // =========================================================================
// Formatting.kt - la visualización de horas y días
// -------------------------------------------------------------------------
// El servidor envía datos SIN PROCESAR (startHour: 8, startMinute: 0; day:
// "2026-10-05"); el formateo, que depende del idioma, es asunto
// del cliente (ver ejemplo 09).
// =========================================================================
package fr.stahe.rdvmedecins
import fr.stahe.rdvmedecins.api.Slot
import fr.stahe.rdvmedecins.api.ScheduleSlot
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
import java.time.format.FormatStyle
import java.util.Locale
// "8:05" en lugar de "8:5"
fun time(h: Int, m: Int) = "$h:${m.toString().padStart(2, '0')}"
// "8:00 - 8:20"
fun timeRange(c: Slot) = "${time(c.startHour, c.startMinute)} - ${time(c.endHour, c.endMinute)}"
fun timeRange(c: ScheduleSlot) = "${time(c.startHour, c.startMinute)} - ${time(c.endHour, c.endMinute)}"
fun today(): String = LocalDate.now().toString() // "yyyy-MM-dd", el formato de la API
// true si day es una fecha que existe, en el formato yyyy-MM-dd ("2026-02-30": no)
fun isValidDate(day: String): Boolean =
Regex("^\\d{4}-\\d{2}-\\d{2}$").matches(day) && runCatching { LocalDate.parse(day) }.isSuccess
// "lundi 5 octobre 2026" / "Monday, October 5, 2026"
fun longDate(day: String, language: String): String =
LocalDate.parse(day).format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(Locale.forLanguageTag(language)))
// el calendario de Material trabaja en milisegundos (UTC)
fun toMillis(day: String): Long = LocalDate.parse(day).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
fun fromMillis(ms: Long): String = Instant.ofEpochMilli(ms).atZone(ZoneOffset.UTC).toLocalDate().toString()
|
El servidor envía datos SIN PROCESAR ([startHour: 8], [day: "2026-10-05"]): su formato, que depende del idioma, es responsabilidad del cliente (consulte el ejemplo 09).
11.7. La capa de acceso a la API
11.7.1. api/HttpClient.kt
| // =========================================================================
// api/HttpClient.kt - un cliente HTTP que maneja COOKIES
// -------------------------------------------------------------------------
// Tomado del ejemplo 23 (common/HttpClient.kt). El servidor de RdvMedecins
// coloca el token JWT en una cookie httpOnly. En un teléfono no hay
// navegador que la conserve: es el "cookie jar" (CookieJar) del
// cliente OkHttp quien la almacena y la envía de vuelta con cada solicitud. Las
// cookies también se almacenan en el dispositivo (SharedPreferences): seguimos
// con la sesión iniciada al detener y volver a iniciar la aplicación.
// Viajan dos cookies: el token (rdvmedecins_jwt, ruta /api) y el
// pase de creación de cuenta (ruta /api/register).
// =========================================================================
package fr.stahe.rdvmedecins.api
import android.content.Context
import android.content.SharedPreferences
import androidx.core.content.edit
import fr.stahe.rdvmedecins.Config
import okhttp3.Cookie
import okhttp3.CookieJar
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit
class DeviceCookieJar(private val storage: SharedPreferences) : CookieJar {
// nombre de la cookie -> la cookie
private val cookies = mutableMapOf<String, Cookie>()
init {
// las cookies recordadas durante un uso anterior
val base = Config.serverUrl.toHttpUrl()
for (text in storage.getStringSet(KEY, emptySet()).orEmpty()) {
Cookie.parse(base, text)?.let { cookies[it.name] = it }
}
}
// la respuesta trae cookies: las almacenamos; una cookie expirada (así
// borra el servidor el token al cerrar sesión) se quita
@Synchronized
override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
for (c in cookies) {
if (c.expiresAt < System.currentTimeMillis() || c.value.isEmpty()) {
this.cookies.remove(c.name)
} else {
this.cookies[c.name] = c
}
}
storage.edit { putStringSet(KEY, this@DeviceCookieJar.cookies.values.map { it.toString() }.toSet()) }
}
// sale una solicitud: las cookies que le corresponden, no expiradas
@Synchronized
override fun loadForRequest(url: HttpUrl): List<Cookie> =
cookies.values.filter { it.expiresAt >= System.currentTimeMillis() && it.matches(url) }
companion object {
private const val KEY = "rdvmedecins.cookies"
}
}
fun createHttpClient(context: Context): OkHttpClient = OkHttpClient.Builder()
.cookieJar(DeviceCookieJar(context.getSharedPreferences("rdvmedecins", Context.MODE_PRIVATE)))
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.build()
|
El cliente HTTP del ejemplo 23 y su almacén de cookies. Circulan dos cookies: el token ([rdvmedecins_jwt]) y el pase de creación de cuenta.
11.7.2. api/ApiError.kt
| // =========================================================================
// api/ApiError.kt - UNA clase para todos los errores de la API
// -------------------------------------------------------------------------
// Tomado del ejemplo 24 (common/ApiError.kt). Todas las respuestas de error
// del servidor tienen la misma forma:
// { "statusCode": 409, "key": "ERRORS.LOGIN_TAKEN", "params": {...}, "fields": {...} }
// Una solicitud sin respuesta (red, servidor detenido) o una respuesta que
// no proviene de nuestro servidor también se convierten en un ApiError.
// =========================================================================
package fr.stahe.rdvmedecins.api
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonObject
class ApiError(
val statusCode: Int, // 0: el servidor no respondió
val key: String, // p. ej. "ERRORS.LOGIN_TAKEN"
val params: Map<String, String> = emptyMap(),
val fields: Map<String, String> = emptyMap(),
) : Exception("$statusCode $key") {
override fun toString() = "$statusCode $key"
companion object {
fun fromResponse(statusCode: Int, body: String): ApiError {
val json = runCatching { Json.parseToJsonElement(body).jsonObject }.getOrNull()
val key = (json?.get("key") as? JsonPrimitive)?.content
if (json == null || key == null) {
// sin clave: respondió el proxy o la red en lugar del servidor
return ApiError(statusCode, if (statusCode >= 500) "ERRORS.SERVER_UNREACHABLE" else "ERRORS.SERVER_ERROR")
}
return ApiError(statusCode, key, strings(json["params"]), strings(json["fields"]))
}
private fun strings(json: Any?): Map<String, String> =
(json as? JsonObject)?.mapValues { (_, v) -> (v as? JsonPrimitive)?.content ?: v.toString() } ?: emptyMap()
}
}
|
11.7.3. api/ApiClient.kt
| // =========================================================================
// api/ApiClient.kt - TODAS las solicitudes a la API pasan por aquí
// -------------------------------------------------------------------------
// Tomado del ejemplo 24 (common/Api.kt), con una novedad: el manejo
// centralizado de la respuesta 401.
//
// Un 401 puede llegar en cualquier momento: el token ha expirado (2 horas), la
// cuenta ha sido eliminada, el servidor se ha reiniciado con otra clave
// secreta... En lugar de manejar este caso en cada pantalla, lo manejamos
// AQUÍ, una sola vez. Pero este archivo no conoce ni la navegación ni los
// mensajes (no depende de nada): llama a una función que se le entregó
// al inicio (onSessionExpired, ver RdvMedecinsApplication.kt),
// que olvida al usuario; la navegación, que observa la sesión, vuelve entonces
// a la pantalla de inicio de sesión.
//
// Algunas solicitudes manejan su 401 por sí mismas (el inicio de sesión, GET
// /api/auth/me...): son "públicas" (ver RdvMedecinsApi.kt).
// =========================================================================
package fr.stahe.rdvmedecins.api
import fr.stahe.rdvmedecins.Config
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException
class ApiClient(private val client: OkHttpClient) {
// qué hacer cuando el servidor responde 401 a una solicitud protegida
var onSessionExpired: () -> Unit = {}
// isPublic: true para las rutas que manejan el 401 por sí mismas.
// withContext(Dispatchers.Main.immediate): la función SIEMPRE termina
// en el hilo principal, el hilo de la pantalla, sea cual sea el hilo
// del llamador (en una aplicación, eso ya ocurre: nada
// cambia; en una prueba instrumentada, el llamador puede estar en otro lado).
// Por lo tanto, al regresar, podemos navegar o tocar el estado sin preocupaciones
suspend fun request(method: String, url: String, body: JsonElement? = null, isPublic: Boolean = false): JsonElement? =
withContext(Dispatchers.Main.immediate) { execute(method, url, body, isPublic) }
private suspend fun execute(method: String, url: String, body: JsonElement?, isPublic: Boolean): JsonElement? {
val response = withContext(Dispatchers.IO) {
val httpBody = body?.toString()?.toRequestBody("application/json".toMediaType())
val request = Request.Builder().url("${Config.serverUrl}/api$url").method(method, httpBody).build()
try {
client.newCall(request).execute().use { it.code to it.body?.string().orEmpty() }
} catch (e: IOException) {
// sin respuesta: red caída, servidor detenido, dirección incorrecta
throw ApiError(0, "ERRORS.SERVER_UNREACHABLE")
}
}
// desestructuración del par (code, text)
val (code, text) = response
if (code >= 400) {
val error = ApiError.fromResponse(code, text)
if (error.statusCode == 401 && !isPublic) {
// de vuelta en el hilo de la pantalla: podemos tocar el estado
onSessionExpired()
// la pantalla que esperaba la respuesta también mostrará ESTE mensaje
throw ApiError(401, "ERRORS.SESSION_EXPIRED")
}
throw error
}
return if (text.isEmpty()) null else Json.parseToJsonElement(text)
}
}
|
- líneas 42–43: la función termina SIEMPRE en el hilo principal, el hilo de la pantalla ([Dispatchers.Main.immediate]): al regresar, se puede navegar o interactuar con el estado sin precauciones;
- líneas 46–53: la solicitud, en el hilo de E/S (consulte el ejemplo 24);
- líneas 60–64: la novedad: un 401 en una ruta protegida indica una sesión vencida. Lo gestionamos AQUÍ, una vez para todas las solicitudes: [onSessionExpired()], y luego un [ApiError] cuya clave es el mensaje que se debe mostrar.
11.7.4. api/Types.kt
| // =========================================================================
// api/Types.kt - los objetos JSON intercambiados con el servidor
// -------------------------------------------------------------------------
// La traducción, a clases Kotlin @Serializable, de la API descrita en
// el capítulo "El servidor, una caja negra" (ver common/Types.kt de los
// ejemplos). Leer un JSON que no tiene la forma esperada falla
// apenas se recibe.
// =========================================================================
package fr.stahe.rdvmedecins.api
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.serializer
enum class Role { ADMIN, DOCTOR, USER }
// POST /api/auth/login, GET /api/auth/me, PUT /api/my-account
@Serializable
data class User(val login: String, val name: String, val role: Role)
// GET /api/captcha
@Serializable
data class Captcha(val id: String, val svg: String)
// un título, un nombre, un apellido
@Serializable
data class Identity(val title: String, val firstName: String, val lastName: String) {
val label get() = "$title $firstName $lastName" // "Mme Alice DURAND"
}
// un médico o un cliente: GET /api/doctors, GET /api/clients/:id...
@Serializable
data class Person(
val id: Int,
val version: Int, // bloqueo optimista: se debe enviar de vuelta con una actualización
val title: String,
val firstName: String,
val lastName: String,
val login: String? = null, // solo para el ADMIN
) {
val label get() = "$title $firstName $lastName"
}
// un intervalo de tiempo
@Serializable
data class Slot(val id: Int, val startHour: Int, val startMinute: Int, val endHour: Int, val endMinute: Int)
// una fila de la agenda, con los DERECHOS del usuario que inició sesión
@Serializable
data class ScheduleSlot(
val id: Int,
val startHour: Int,
val startMinute: Int,
val endHour: Int,
val endMinute: Int,
val free: Boolean,
val patient: Identity?, // null: libre, o tomada por otro paciente
val mine: Boolean, // la cita del paciente que inició sesión
val bookable: Boolean,
val appointmentId: Int?, // definido si el usuario puede cancelar
)
// GET /api/schedule?doctorId=...&day=...
@Serializable
data class Schedule(
val doctor: Person,
val day: String, // "yyyy-MM-dd"
val slots: List<ScheduleSlot>,
val info: String?, // clave de traducción (paciente que ya tiene una cita)
)
// una cita de GET /api/my-area
@Serializable
data class Appointment(val id: Int, val day: String, val slot: Slot, val doctor: Person)
// GET /api/my-area
@Serializable
data class MyArea(val patient: Identity, val appointments: List<Appointment>)
// GET /api/my-account
@Serializable
data class MyAccount(val title: String, val firstName: String, val lastName: String, val login: String, val version: Int)
val apiJson = Json { ignoreUnknownKeys = true }
// JsonElement -> objeto Kotlin
inline fun <reified T> JsonElement?.read(): T =
apiJson.decodeFromJsonElement(serializer<T>(), this ?: throw IllegalStateException("empty response"))
|
11.7.5. api/RdvMedecinsApi.kt
| // =========================================================================
// api/RdvMedecinsApi.kt - una función por cada ruta de la API
// -------------------------------------------------------------------------
// La "capa de acceso a datos" del cliente (un "repository"): las pantallas
// llaman a estas funciones tipadas, sin saber nada de las URL, de OkHttp ni
// de JSON. Si la API cambia, solo cambia este archivo.
// Cada función es suspendida; si falla, lanza un ApiError.
// Los datos del formulario son simples Map<String, Any?>: sus
// claves son los nombres de los campos que espera el servidor, y los de los
// errores que este devuelve (ApiError.fields).
// =========================================================================
package fr.stahe.rdvmedecins.api
import android.net.Uri
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.boolean
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
// /api/doctors o /api/clients: ambos se manejan de la misma manera
enum class PersonType(val path: String) { DOCTORS("doctors"), CLIENTS("clients") }
typealias FormData = Map<String, Any?>
// datos del formulario -> un objeto JSON
fun FormData.toJson(): JsonObject = JsonObject(
mapValues { (_, v) ->
when (v) {
null -> JsonNull
is Number -> JsonPrimitive(v)
is Boolean -> JsonPrimitive(v)
else -> JsonPrimitive(v.toString())
}
},
)
class RdvMedecinsApi(private val client: ApiClient) {
private suspend fun get(url: String, isPublic: Boolean = false) = client.request("GET", url, isPublic = isPublic)
private suspend fun post(url: String, body: JsonElement, isPublic: Boolean = false) =
client.request("POST", url, body, isPublic)
// inicio de sesión (rutas públicas)
suspend fun captcha(): Captcha = get("/captcha", isPublic = true).read()
suspend fun me(): User = get("/auth/me", isPublic = true).read()
suspend fun login(login: String, password: String, captchaId: String, captcha: String): User =
post(
"/auth/login",
mapOf("login" to login, "password" to password, "captchaId" to captchaId, "captcha" to captcha).toJson(),
isPublic = true,
).read()
suspend fun logout() {
post("/auth/logout", JsonObject(emptyMap()), isPublic = true)
}
// creación de cuenta (pública)
suspend fun registrationAccess(captchaId: String, captcha: String) {
post("/register/access", mapOf("captchaId" to captchaId, "captcha" to captcha).toJson(), isPublic = true)
}
suspend fun registrationAccessStatus(): Boolean =
get("/register/access", isPublic = true)?.jsonObject?.get("valid")?.jsonPrimitive?.boolean ?: false
// devuelve el login de la cuenta creada
suspend fun register(data: FormData): String =
post("/register", data.toJson(), isPublic = true)!!.jsonObject["login"]!!.jsonPrimitive.content
// agenda y citas
// doctorId null: para un médico que inició sesión, SU agenda
suspend fun schedule(doctorId: Int?, day: String): Schedule {
val params = Uri.Builder().appendQueryParameter("day", day).apply {
if (doctorId != null) appendQueryParameter("doctorId", "$doctorId")
}.build().encodedQuery
return get("/schedule?$params").read()
}
suspend fun book(day: String, slotId: Int, clientId: Int?) {
post("/appointments", buildMap { put("day", day); put("slotId", slotId); if (clientId != null) put("clientId", clientId) }.toJson())
}
suspend fun cancelAppointment(appointmentId: Int) {
client.request("DELETE", "/appointments/$appointmentId")
}
// médicos y clientes
suspend fun list(type: PersonType): List<Person> = get("/${type.path}").read()
suspend fun read(type: PersonType, id: Int): Person = get("/${type.path}/$id").read()
suspend fun add(type: PersonType, data: FormData): Person = post("/${type.path}", data.toJson()).read()
suspend fun update(type: PersonType, id: Int, data: FormData): Person =
client.request("PUT", "/${type.path}/$id", data.toJson()).read()
suspend fun delete(type: PersonType, id: Int) {
client.request("DELETE", "/${type.path}/$id")
}
// el área del paciente
suspend fun myArea(): MyArea = get("/my-area").read()
suspend fun myAccount(): MyAccount = get("/my-account").read()
suspend fun updateMyAccount(data: FormData): User = client.request("PUT", "/my-account", data.toJson()).read()
suspend fun deleteMyAccount(currentPassword: String) {
client.request("DELETE", "/my-account", mapOf("currentPassword" to currentPassword).toJson())
}
}
|
- línea 24: médicos o clientes: una enumeración, con la ruta de la API para cada uno;
- líneas 26–29: datos de formulario: un [Map] cuyas claves son los nombres de los campos que espera el servidor, convertido a JSON;
- líneas 40–110: una función por cada ruta de la API, agrupadas por tema; las rutas que gestionan por sí mismas el 401 son “públicas”.
11.8. Idiomas
11.8.1. i18n/Translations.kt
| // =========================================================================
// i18n/Translations.kt - los diccionarios, el idioma actual
// -------------------------------------------------------------------------
// Tomado del ejemplo 25 (Dictionary.kt). Los diccionarios
// (assets/i18n/fr.json, en.json) son los de los clientes Vue.js, Angular,
// React y Flutter: mismas claves, mismas convenciones ({{param}}). El servidor
// solo devuelve CLAVES ("ERRORS.LOGIN_TAKEN"): aquí es donde
// se convierten en texto.
// - t("KEY", mapOf("param" to value)): el texto del idioma actual;
// - changeLanguage("fr"): el idioma PROPIO de la aplicación (ver ejemplo
// 21), recordado por Android; la actividad se recrea en el nuevo
// idioma: nuestros textos, pero también los de Android (el calendario), las
// fechas y los números.
// =========================================================================
package fr.stahe.rdvmedecins.i18n
import android.content.Context
import androidx.appcompat.app.AppCompatDelegate
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.staticCompositionLocalOf
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalContext
import androidx.core.os.LocaleListCompat
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
val languages = listOf("fr", "en")
class Translations(context: Context, val language: String) {
private val root: JsonObject = context.assets.open("i18n/$language.json").bufferedReader().use {
Json.parseToJsonElement(it.readText()) as JsonObject
}
// "LOGIN.TITLE" -> root["LOGIN"]["TITLE"]; null si falta
private fun find(key: String): String? {
var node: JsonElement? = root
for (part in key.split('.')) node = (node as? JsonObject)?.get(part)
return (node as? JsonPrimitive)?.takeIf { it.isString }?.content
}
// una clave desconocida se muestra tal cual: vemos de inmediato lo que falta
fun t(key: String, params: Map<String, String> = emptyMap()): String {
val text = find(key) ?: return key
return Regex("\\{\\{(\\w+)\\}\\}").replace(text) { m -> params[m.groupValues[1]] ?: m.value }
}
}
// el idioma de la aplicación: Android lo recuerda y recrea la actividad
fun changeLanguage(language: String) {
AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags(language))
}
// las traducciones, provistas a todas las pantallas (ver MainActivity.kt)
val LocalTranslations = staticCompositionLocalOf<Translations> { error("no translations provided") }
// las traducciones del idioma de la configuración actual
@Composable
fun rememberTranslations(): Translations {
val context = LocalContext.current
val language = LocalConfiguration.current.locales[0].language.let { if (it in languages) it else "en" }
return remember(language) { Translations(context, language) }
}
// un atajo, en una función @Composable: t("LOGIN.TITLE")
@Composable
fun t(key: String, params: Map<String, String> = emptyMap()): String = LocalTranslations.current.t(key, params)
|
- líneas 32–45: el diccionario del ejemplo 25, con los mismos archivos que otros clientes;
- líneas 57–64: las traducciones del idioma actual, proporcionadas a todas las pantallas (consulte [MainActivity.kt]); el diccionario se vuelve a leer solo si cambia el idioma;
- línea 69: un atajo [@Composable], [t("LOGIN.TITLE")]. Como cualquier función [@Composable], solo se puede llamar desde dentro de otra: en una lambda ordinaria (un [onClick], el [text] de una lista desplegable), primero hay que traducirlo, o usar [LocalTranslations.current.t(...)].
11.9. El estado compartido
11.9.1. state/Session.kt
| // =========================================================================
// state/Session.kt - ¿QUIÉN ha iniciado sesión?
// -------------------------------------------------------------------------
// El usuario que inició sesión (o null), en un estado observado por Compose
// (mutableStateOf): las pantallas que lo leen se recomponen cuando
// cambia, y la navegación (ver navigation/Navigation.kt) lo observa para
// salir de una pantalla que ya no está permitida.
//
// El token JWT en sí NO está aquí: está en una cookie, almacenada por
// el cliente HTTP. La sesión solo guarda la DESCRIPCIÓN del usuario
// ({ login, name, role }).
//
// Cuando la aplicación se inicia, la sesión está vacía: check() le pregunta
// al servidor, una sola vez, quién ha iniciado sesión (GET /api/auth/me).
// =========================================================================
package fr.stahe.rdvmedecins.state
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import fr.stahe.rdvmedecins.api.RdvMedecinsApi
import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.api.User
class Session(private val api: RdvMedecinsApi) {
var user by mutableStateOf<User?>(null)
private set
// true después de un cierre de sesión DESEADO (botón, eliminación de la cuenta);
// false después de una sesión expirada. La navegación lo tiene en cuenta
var leftVoluntarily = false
private set
// la pantalla que queríamos ver cuando expiró la sesión (una ruta):
// volveremos a ella después de iniciar sesión
var requestedScreen: Any? = null
// la pantalla mostrada (una ruta), registrada por cada pantalla protegida
var currentScreen: Any? = null
// ¿ya se hizo la pregunta "quién ha iniciado sesión"?
var checked by mutableStateOf(false)
private set
// solo le pregunta al servidor la primera vez
suspend fun check() {
if (checked) return
user = try {
api.me()
} catch (e: Exception) {
null // 401: nadie; o servidor inalcanzable
}
checked = true
}
suspend fun login(login: String, password: String, captchaId: String, captcha: String) {
change(api.login(login, password, captchaId, captcha))
}
// el usuario ha cambiado su nombre o su login (PUT /api/my-account)
fun update(u: User) = change(u)
suspend fun logout() {
try {
api.logout()
} finally {
forget(voluntary = true) // incluso si el servidor no responde
}
}
// sin preguntarle nada al servidor: sesión expirada, cuenta eliminada
fun forget(voluntary: Boolean = false) = change(null, voluntary)
private fun change(u: User?, voluntary: Boolean = false) {
leftVoluntarily = voluntary
user = u
}
}
// lo que se deduce del usuario: propiedades de EXTENSIÓN del tipo
// User? (también se aplican a null)
val User?.isAdmin get() = this?.role == Role.ADMIN
val User?.isPatient get() = this?.role == Role.USER
// ADMIN y DOCTOR: reservan y cancelan las citas de cualquier paciente
val User?.isManager get() = this?.role == Role.ADMIN || this?.role == Role.DOCTOR
|
- líneas 26–27: el usuario, un estado observado: la barra superior, el menú y la navegación lo leen;
- líneas 31–39: lo necesario para volver, tras vencer una sesión, a la pantalla que se quería ver;
- líneas 82–86: propiedades de EXTENSIÓN del tipo [User?]: también se aplican a [null] ([this?.role]).
11.9.2. state/Messages.kt
| // =========================================================================
// state/Messages.kt - los mensajes mostrados al usuario
// -------------------------------------------------------------------------
// Misma presentación que los otros clientes de RdvMedecins:
// - un ÉXITO se muestra en la PARTE SUPERIOR de la pantalla (banner verde);
// - un ERROR en la PARTE INFERIOR (banner rosa), siempre visible.
// Un mensaje es una CLAVE de traducción (+ sus parámetros): por lo tanto se
// traduce de nuevo por sí solo si el usuario cambia el idioma.
//
// Los mensajes "flash": una acción que termina con un cambio de
// pantalla (reservar, agregar un médico...) deja su mensaje con
// flash(); se mostrará en la SIGUIENTE pantalla, y luego desaparecerá en la
// navegación siguiente. La navegación es quien llama a newPage() en
// cada cambio de pantalla (ver navigation/Navigation.kt).
// =========================================================================
package fr.stahe.rdvmedecins.state
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import fr.stahe.rdvmedecins.api.ApiError
data class Message(val key: String, val params: Map<String, String> = emptyMap())
class Messages {
var success by mutableStateOf<Message?>(null)
private set
var error by mutableStateOf<Message?>(null)
private set
// los mensajes que se mostrarán en la siguiente pantalla
private var pendingSuccess: Message? = null
private var pendingError: Message? = null
fun showSuccess(key: String, params: Map<String, String> = emptyMap()) {
success = Message(key, params)
error = null
}
fun showError(key: String, params: Map<String, String> = emptyMap()) {
error = Message(key, params)
success = null
}
fun showApiError(e: ApiError) = showError(e.key, e.params)
fun clear() {
success = null
error = null
}
// para la SIGUIENTE pantalla
fun flash(key: String, params: Map<String, String> = emptyMap(), success: Boolean = true) {
if (success) pendingSuccess = Message(key, params) else pendingError = Message(key, params)
}
// una nueva pantalla: los mensajes de la anterior desaparecen, los
// mensajes flash aparecen
fun newPage() {
success = pendingSuccess
error = pendingError
pendingSuccess = null
pendingError = null
}
}
|
11.9.3. state/Cache.kt
| // =========================================================================
// state/Cache.kt - los datos ya leídos del servidor
// -------------------------------------------------------------------------
// La lista de médicos casi nunca cambia: no hace falta leerla de nuevo en
// cada visita de la agenda. El caché conserva el resultado de cada lectura,
// bajo una CLAVE ("doctors", "schedule/1/2026-10-05"...):
//
// val doctors = cache.read("doctors") { api.list(PersonType.DOCTORS) }
//
// devuelve el resultado ya conservado, o lanza la lectura y conserva
// su resultado. Dos solicitudes simultáneas para la misma clave comparten la misma
// lectura (un Deferred: un resultado por venir). Una lectura fallida no se
// conserva: la siguiente volverá a intentarlo.
// Después de una actualización, las claves afectadas se INVALIDAN:
// cache.invalidate("schedule"). La propiedad version, un estado observado,
// cambia entonces: las pantallas que la leen (incluso ocultas bajo un diálogo)
// vuelven a leer sus datos. Es, en pocas líneas, lo que hace la
// biblioteca TanStack Query del cliente React.
// =========================================================================
package fr.stahe.rdvmedecins.state
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.setValue
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.async
class Cache(private val scope: CoroutineScope) {
private val reads = mutableMapOf<String, Deferred<Any?>>()
var version by mutableIntStateOf(0)
private set
@Suppress("UNCHECKED_CAST")
suspend fun <T> read(key: String, load: suspend () -> T): T {
val reading = reads.getOrPut(key) { scope.async { load() } }
try {
return reading.await() as T
} catch (e: Exception) {
// si falla, esta lectura se olvida (la siguiente solicitud volverá a intentarlo)
if (reads[key] === reading) reads.remove(key)
throw e
}
}
// olvida todas las claves que empiezan con prefix, y notifica a las pantallas
fun invalidate(prefix: String) {
reads.keys.removeAll { it.startsWith(prefix) }
version++
}
// cambio de usuario: todo se olvida, SIN notificar (las pantallas del
// usuario anterior están a punto de desaparecer, no deben volver a leer nada)
fun clear() = reads.clear()
}
|
- Líneas 36–39: [getOrPut]: si ya se inició una operación de lectura para esta clave, se continúa con esa; de lo contrario, se inicia una nueva. [async] lanza una corrutina que produce un [Deferred], un resultado por venir: dos solicitudes simultáneas esperan ([await]) la MISMA lectura;
- Líneas 48–50: [invalidate]: las pantallas que leen [version] desde la clave de un [LaunchedEffect] vuelven a leer sus datos.
11.10. Navegación
11.10.1. navigation/Screens.kt
| // =========================================================================
// navigation/Screens.kt - las RUTAS de la aplicación (ver ejemplo 17)
// -------------------------------------------------------------------------
// Las mismas pantallas que los otros clientes (/login, /schedule, /doctors,
// /my-area...), descritas por objetos Kotlin @Serializable, reunidos
// en un objeto Screens: Screens.Schedule(doctorId = 1, day = "2026-10-05").
// TODO el estado de una pantalla está en su ruta (el médico, el día...): el
// botón Atrás del teléfono lo restaura tal cual.
// El diálogo de reserva también es una ruta (Screens.Booking):
// un destino de tipo "dialog", mostrado ENCIMA de la agenda; el
// botón Atrás lo cierra.
// =========================================================================
package fr.stahe.rdvmedecins.navigation
import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.api.User
import kotlinx.serialization.Serializable
object Screens {
// la primera pantalla: el tiempo de preguntarle al servidor quién ha iniciado sesión
@Serializable
object Startup
// login: prellenado justo después de la creación de una cuenta
@Serializable
data class Login(val login: String = "")
// day: tal cual, quizá inválido (la pantalla lo verifica)
@Serializable
data class Schedule(val doctorId: Int? = null, val day: String? = null)
@Serializable
data class Booking(val doctorId: Int?, val day: String, val slotId: Int)
// las pantallas de gestión de los médicos O de los clientes (ADMIN)
@Serializable
data class Persons(val type: PersonType)
// id null: creación; de lo contrario, actualización
@Serializable
data class Person(val type: PersonType, val id: Int? = null)
@Serializable
object Register
@Serializable
object MyArea
@Serializable
object MyAccount
}
// los roles permitidos para una pantalla protegida (null: todos los roles con sesión iniciada)
val adminRoles = setOf(Role.ADMIN)
val patientRoles = setOf(Role.USER)
// la página de inicio de cada rol, justo después de iniciar sesión
fun home(u: User): Any = if (u.role == Role.USER) Screens.MyArea else Screens.Schedule()
|
Las rutas de navegación de la aplicación, organizadas en un objeto [Screens]. TODO el estado de una pantalla se almacena en su ruta de navegación; el botón Atrás del teléfono lo restaura exactamente como estaba. La ventana de reserva también es una ruta de navegación.
11.10.2. navigation/Navigation.kt
| // =========================================================================
// navigation/Navigation.kt - las pantallas de la aplicación y sus derechos
// -------------------------------------------------------------------------
// El NavHost (ver ejemplo 17) muestra la pantalla de la ruta actual, dentro del
// AppLayout (barra superior, menú, mensajes).
//
// Los GUARDIAS (ver ejemplo 18):
// - una pantalla protegida se envuelve con Protected(route, roles): solo se
// muestra a un usuario con sesión iniciada y con el rol correcto (de lo contrario,
// la pantalla de error 403);
// - un efecto observa la SESIÓN: un usuario que desaparece (cierre de sesión,
// sesión expirada) vuelve a la pantalla de inicio de sesión; un usuario que
// aparece (inicio de sesión) sale de la pantalla de inicio de sesión hacia la pantalla solicitada
// antes de la expiración, o si no hacia la página de inicio de su rol.
// RECORDATORIO: estas verificaciones son solo una COMODIDAD (no mostrar una pantalla
// inútil). La protección de los datos la garantiza el servidor, que
// verifica de nuevo el token y el rol en CADA solicitud.
//
// Los mensajes "flash": en cada nueva pantalla, Messages.newPage().
// =========================================================================
package fr.stahe.rdvmedecins.navigation
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.navigation.NavDestination
import androidx.navigation.NavDestination.Companion.hasRoute
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.dialog
import androidx.navigation.compose.rememberNavController
import androidx.navigation.toRoute
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.pages.SchedulePage
import fr.stahe.rdvmedecins.pages.LoginPage
import fr.stahe.rdvmedecins.pages.StartupPage
import fr.stahe.rdvmedecins.pages.ErrorPage
import fr.stahe.rdvmedecins.pages.PatientAreaPage
import fr.stahe.rdvmedecins.pages.RegisterPage
import fr.stahe.rdvmedecins.pages.MyAccountPage
import fr.stahe.rdvmedecins.pages.PersonFormPage
import fr.stahe.rdvmedecins.pages.PersonsPage
import fr.stahe.rdvmedecins.widgets.BookingDialog
import fr.stahe.rdvmedecins.widgets.AppLayout
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.map
// las pantallas públicas (sin inicio de sesión)
fun isPublic(d: NavDestination) =
d.hasRoute<Screens.Login>() || d.hasRoute<Screens.Register>() || d.hasRoute<Screens.Startup>()
// ir a una pantalla VACIANDO la pila: Atrás no regresará a la pantalla anterior
fun NavHostController.goTo(route: Any) {
navigate(route) {
popUpTo(graph.id) { inclusive = true }
launchSingleTop = true
}
}
@Composable
fun Navigation() {
val nav = rememberNavController()
val d = LocalDependencies.current
val session = d.session
val user = session.user
// los mensajes flash: en cada nueva pantalla (una nueva entrada de la pila)
LaunchedEffect(nav) {
nav.currentBackStackEntryFlow.map { it.id }.distinctUntilChanged().collect { d.messages.newPage() }
}
// la sesión cambia: se relanza en cada cambio de usuario
LaunchedEffect(user, session.checked) {
if (!session.checked) return@LaunchedEffect
val here = nav.currentBackStackEntry?.destination ?: return@LaunchedEffect
if (user == null && !isPublic(here)) {
// sesión expirada: se recuerda la pantalla actual, para volver a ella
session.requestedScreen = if (session.leftVoluntarily) null else session.currentScreen
nav.goTo(Screens.Login())
} else if (user != null && (here.hasRoute<Screens.Login>() || here.hasRoute<Screens.Startup>())) {
// sesión iniciada: la pantalla de inicio de sesión ya no tiene sentido
val target = session.requestedScreen ?: home(user)
session.requestedScreen = null
nav.goTo(target)
}
}
AppLayout(nav) {
NavHost(navController = nav, startDestination = Screens.Startup) {
composable<Screens.Startup> { StartupPage(onNobody = { nav.goTo(Screens.Login()) }) }
composable<Screens.Login> { e ->
LoginPage(login = e.toRoute<Screens.Login>().login.take(30), onRegister = { nav.navigate(Screens.Register) })
}
composable<Screens.Schedule> { e ->
val route = e.toRoute<Screens.Schedule>()
Protected(route) {
SchedulePage(
doctorId = route.doctorId,
day = route.day,
// ver otra agenda: la ruta actual se REEMPLAZA
onView = { id, day ->
nav.navigate(Screens.Schedule(id, day)) { popUpTo<Screens.Schedule> { inclusive = true } }
},
// reservar: el diálogo se APILA encima de la agenda
onBook = { id, day, slotId -> nav.navigate(Screens.Booking(id, day, slotId)) },
onMyArea = { nav.goTo(Screens.MyArea) },
)
}
}
dialog<Screens.Booking> { e ->
val route = e.toRoute<Screens.Booking>()
Protected(route) { BookingDialog(route, onClose = { nav.popBackStack() }) }
}
composable<Screens.Persons> { e ->
val route = e.toRoute<Screens.Persons>()
Protected(route, adminRoles) {
PersonsPage(
type = route.type,
onAdd = { nav.navigate(Screens.Person(route.type)) },
onEdit = { id -> nav.navigate(Screens.Person(route.type, id)) },
)
}
}
composable<Screens.Person> { e ->
val route = e.toRoute<Screens.Person>()
Protected(route, adminRoles) {
// de vuelta a la lista: el formulario se desapila
PersonFormPage(type = route.type, id = route.id, onList = {
if (!nav.popBackStack()) nav.goTo(Screens.Persons(route.type))
})
}
}
composable<Screens.Register> {
RegisterPage(onLogin = { login -> nav.goTo(Screens.Login(login)) })
}
composable<Screens.MyArea> {
Protected(Screens.MyArea, patientRoles) {
PatientAreaPage(
onMyAccount = { nav.navigate(Screens.MyAccount) },
onSchedule = { id, day -> nav.navigate(Screens.Schedule(id, day)) },
)
}
}
composable<Screens.MyAccount> {
Protected(Screens.MyAccount, patientRoles) {
MyAccountPage(onMyArea = { nav.goTo(Screens.MyArea) })
}
}
}
}
}
// una pantalla protegida: con sesión iniciada y, si roles no es null, con uno de estos roles
@Composable
fun Protected(route: Any, roles: Set<Role>? = null, content: @Composable () -> Unit) {
val session = LocalDependencies.current.session
val u = session.user ?: return // sin sesión iniciada: la navegación vuelve al inicio de sesión
// la pantalla mostrada, recordada para volver a ella después de una sesión expirada
LaunchedEffect(route) { session.currentScreen = route }
if (roles != null && u.role !in roles) {
ErrorPage(code = 403)
} else {
content()
}
}
|
- líneas 54–57: ir a una pantalla BORRANDO la pila: Atrás no regresará a la pantalla anterior (no se vuelve a la pantalla de inicio de sesión después de iniciar sesión);
- líneas 69–70: mensajes flash: [currentBackStackEntryFlow], [Flow] para las pantallas sucesivas;
- líneas 74–85: LA guardia de la aplicación: un efecto que se activa cada vez que cambia el usuario. Si nadie está en una pantalla protegida: al iniciar sesión (conservando la pantalla actual si la sesión venció); si alguien está en la pantalla de inicio de sesión: a la pantalla solicitada y, si no, a la pantalla de inicio de su rol;
- líneas 89–113: el grafo de navegación, en el diseño; [dialog<Screens.Booking>]: un destino que se muestra ENCIMA de la pantalla anterior, que el botón Atrás cierra;
- líneas 156–164: [Protected]: sin sesión iniciada, nada (el efecto anterior remite al inicio de sesión); rol incorrecto, la pantalla de error 403.
11.11. Componentes reutilizables
| // =========================================================================
// widgets/AppLayout.kt - el DISEÑO común a todas las pantallas
// -------------------------------------------------------------------------
// Envuelve el NavHost (ver navigation/Navigation.kt):
// - la barra superior: título, idioma (FR / EN), cierre de sesión;
// - el menú lateral ("drawer", ModalNavigationDrawer), abierto por el
// botón ☰: las pantallas permitidas para el rol del usuario. "Doctors" y
// "Patients" solo aparecen para el ADMIN: una simple comodidad
// de visualización, ya que la protección real es la del servidor;
// - un mensaje de éxito en la PARTE SUPERIOR;
// - la pantalla actual (contenido);
// - el panel de errores en la PARTE INFERIOR.
// En una pantalla grande (tableta, teléfono en horizontal), el menú se
// muestra de forma permanente a la izquierda: un NavigationRail en lugar del drawer.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.rdvmedecins.widgets
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ExitToApp
import androidx.compose.material.icons.filled.AccountCircle
import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material.icons.filled.Face
import androidx.compose.material.icons.filled.Home
import androidx.compose.material.icons.filled.Menu
import androidx.compose.material.icons.filled.Person
import androidx.compose.material.icons.filled.Warning
import androidx.compose.material3.DrawerValue
import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.ListItemDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalDrawerSheet
import androidx.compose.material3.ModalNavigationDrawer
import androidx.compose.material3.NavigationDrawerItem
import androidx.compose.material3.NavigationRail
import androidx.compose.material3.NavigationRailItem
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.material3.VerticalDivider
import androidx.compose.material3.rememberDrawerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.navigation.NavDestination
import androidx.navigation.NavDestination.Companion.hasRoute
import androidx.navigation.NavHostController
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.toRoute
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.api.User
import fr.stahe.rdvmedecins.state.isAdmin
import fr.stahe.rdvmedecins.state.isPatient
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.changeLanguage
import fr.stahe.rdvmedecins.i18n.languages
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.navigation.Screens
import fr.stahe.rdvmedecins.navigation.goTo
import kotlinx.coroutines.launch
// una entrada de menú: la ruta a la que lleva, la clave de su etiqueta, su
// ícono, y la prueba que indica si está activa para una pantalla dada
class MenuEntry(val route: Any, val key: String, val icon: ImageVector, val active: (NavDestination, Any?) -> Boolean)
fun menuEntries(u: User?): List<MenuEntry> {
if (u == null) return emptyList()
// buildList: llenamos una lista, con ifs
return buildList {
if (u.isPatient) add(MenuEntry(Screens.MyArea, "APP.MENU_MY_AREA", Icons.Default.Home) { d, _ -> d.hasRoute<Screens.MyArea>() })
add(MenuEntry(Screens.Schedule(), "APP.MENU_SCHEDULE", Icons.Default.DateRange) { d, _ -> d.hasRoute<Screens.Schedule>() })
if (u.isAdmin) {
add(MenuEntry(Screens.Persons(PersonType.DOCTORS), "APP.MENU_DOCTORS", Icons.Default.Face) { _, type -> type == PersonType.DOCTORS })
add(MenuEntry(Screens.Persons(PersonType.CLIENTS), "APP.MENU_PATIENTS", Icons.Default.Person) { _, type -> type == PersonType.CLIENTS })
}
if (u.isPatient) add(MenuEntry(Screens.MyAccount, "APP.MENU_ACCOUNT", Icons.Default.AccountCircle) { d, _ -> d.hasRoute<Screens.MyAccount>() })
}
}
@Composable
fun AppLayout(nav: NavHostController, content: @Composable () -> Unit) {
val d = LocalDependencies.current
val u = d.session.user
val language = LocalTranslations.current.language
val scope = rememberCoroutineScope()
val entries = menuEntries(u)
// la pantalla actual, y el tipo de personas si es una lista o un formulario
val entry by nav.currentBackStackEntryAsState()
val destination = entry?.destination
val type: PersonType? = when {
destination?.hasRoute<Screens.Persons>() == true -> entry?.toRoute<Screens.Persons>()?.type
destination?.hasRoute<Screens.Person>() == true -> entry?.toRoute<Screens.Person>()?.type
else -> null
}
fun isActive(e: MenuEntry) = destination != null && e.active(destination, type)
// una pantalla grande: al menos 800 dp de ancho
val largeScreen = LocalConfiguration.current.screenWidthDp >= 800
val drawer = rememberDrawerState(DrawerValue.Closed)
var languageMenu by remember { mutableStateOf(false) }
val page = @Composable {
Scaffold(
topBar = {
TopAppBar(
title = { Text(t("APP.TITLE")) },
navigationIcon = {
if (u != null && !largeScreen) {
IconButton(onClick = { scope.launch { drawer.open() } }) { Icon(Icons.Default.Menu, contentDescription = "menu") }
}
},
colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primary,
titleContentColor = MaterialTheme.colorScheme.onPrimary,
navigationIconContentColor = MaterialTheme.colorScheme.onPrimary,
actionIconContentColor = MaterialTheme.colorScheme.onPrimary,
),
actions = {
// FR / EN: un menú; la actividad se recrea en el nuevo idioma
TextButton(onClick = { languageMenu = true }) {
Text(language.uppercase(), color = MaterialTheme.colorScheme.onPrimary, fontWeight = FontWeight.Bold)
}
DropdownMenu(expanded = languageMenu, onDismissRequest = { languageMenu = false }) {
for (l in languages) {
DropdownMenuItem(text = { Text(l.uppercase()) }, onClick = {
languageMenu = false
changeLanguage(l)
})
}
}
if (u != null) {
// la sesión se vacía; la navegación, que la observa, muestra la pantalla de inicio de sesión
IconButton(onClick = { scope.launch { runCatching { d.session.logout() } } }) {
Icon(Icons.AutoMirrored.Filled.ExitToApp, contentDescription = t("APP.LOGOUT"))
}
}
},
)
},
) { innerPadding ->
Row(Modifier.padding(innerPadding).consumeWindowInsets(innerPadding).fillMaxSize()) {
// en una pantalla grande: el menú, de forma permanente
if (u != null && largeScreen) {
NavigationRail {
for (e in entries) {
NavigationRailItem(
selected = isActive(e),
onClick = { nav.goTo(e.route) },
icon = { Icon(e.icon, contentDescription = null) },
label = { Text(t(e.key)) },
)
}
}
VerticalDivider()
}
Column(Modifier.weight(1f).fillMaxSize().imePadding()) {
SuccessMessage()
Column(Modifier.weight(1f)) { content() }
ErrorPanel()
}
}
}
}
if (u == null || largeScreen) {
page()
} else {
// el drawer: solo con sesión iniciada, y solo en una pantalla pequeña
ModalNavigationDrawer(
drawerState = drawer,
drawerContent = {
ModalDrawerSheet {
// el encabezado: quién ha iniciado sesión
Column(Modifier.padding(start = 28.dp, top = 16.dp, end = 16.dp, bottom = 10.dp)) {
Text(u.name, style = MaterialTheme.typography.titleMedium)
SuggestionChip(onClick = {}, label = { Text(u.role.name) })
}
for (e in entries) {
NavigationDrawerItem(
label = { Text(t(e.key)) },
icon = { Icon(e.icon, contentDescription = null) },
selected = isActive(e),
onClick = {
scope.launch { drawer.close() }
nav.goTo(e.route)
},
modifier = Modifier.padding(horizontal = 12.dp),
)
}
}
},
) { page() }
}
}
// el mensaje de éxito, arriba
@Composable
private fun SuccessMessage() {
val messages = LocalDependencies.current.messages
val success = messages.success ?: return
ListItem(
colors = ListItemDefaults.colors(containerColor = Color(0xFFE8F5E9)),
leadingContent = { Icon(Icons.Default.CheckCircle, contentDescription = null, tint = Color(0xFF2E7D32)) },
headlineContent = { Text(t(success.key, success.params), color = Color(0xFF1B5E20)) },
trailingContent = { IconButton(onClick = { messages.clear() }) { Icon(Icons.Default.Close, contentDescription = null) } },
)
}
// el panel de errores, abajo: siempre visible, aunque la pantalla se desplace
@Composable
private fun ErrorPanel() {
val messages = LocalDependencies.current.messages
val error = messages.error ?: return
ListItem(
colors = ListItemDefaults.colors(containerColor = Color(0xFFF8D7DA)),
leadingContent = { Icon(Icons.Default.Warning, contentDescription = null, tint = Color(0xFFC62828)) },
headlineContent = { Text(t(error.key, error.params), color = Color(0xFFB71C1C)) },
trailingContent = { IconButton(onClick = { messages.clear() }) { Icon(Icons.Default.Close, contentDescription = null) } },
)
}
|
- líneas 95–97: entradas del menú, según el rol ([buildList]: llena una lista con [if]);
- líneas 13–174: una pantalla grande, de al menos 800 dp de ancho: el menú es un [NavigationRail], que se muestra de forma permanente; en un teléfono en orientación vertical, un panel lateral ([ModalNavigationDrawer]) que se abre con el botón ☰;
- líneas 228–241: mensajes: éxito en la parte superior, error en la parte inferior.
| // =========================================================================
// widgets/InputField.kt - un campo de formulario completo
// -------------------------------------------------------------------------
// Etiqueta + campo + mensaje de ayuda O mensaje de error. Todos los
// formularios de la aplicación lo usan:
//
// InputField(label = "PERSONS.LASTNAME_LABEL", maxLength = 20,
// value = input["lastName"], onChange = { update("lastName", it) },
// error = submit.errors["lastName"])
//
// Es un componente CONTROLADO (ver ejemplo 11): el valor pertenece al
// formulario padre. label, help y error son CLAVES de traducción;
// params, los parámetros de sus mensajes ({{min}}...).
// =========================================================================
package fr.stahe.rdvmedecins.widgets
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.autofill.ContentType
import androidx.compose.ui.semantics.contentType
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t
@Composable
fun InputField(
label: String,
value: String,
onChange: (String) -> Unit,
error: String? = null,
help: String? = null,
params: Map<String, String> = emptyMap(),
secret: Boolean = false, // una contraseña: caracteres ocultos
maxLength: Int? = null,
// para el administrador de contraseñas del teléfono (usuario, contraseña...)
autofillType: ContentType? = null,
) {
val errorMessage = error?.let { t(it, params) }
val helpMessage = help?.let { t(it, params) }
OutlinedTextField(
value = value,
// el campo rechaza los caracteres sobrantes
onValueChange = { v -> if (maxLength == null || v.length <= maxLength) onChange(v) },
label = { Text(t(label)) },
singleLine = true,
isError = errorMessage != null,
// el error, y si no, la ayuda
supportingText = (errorMessage ?: helpMessage)?.let { m -> { Text(m) } },
visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
keyboardOptions = KeyboardOptions(keyboardType = if (secret) KeyboardType.Password else KeyboardType.Text),
modifier = Modifier
.fillMaxWidth()
.padding(bottom = 4.dp)
.semantics { if (autofillType != null) contentType = autofillType },
)
}
|
| // =========================================================================
// widgets/PersonFields.kt - título, nombre, apellido
// -------------------------------------------------------------------------
// Los campos de identidad, comunes a tres formularios: el de médico / cliente del ADMIN,
// "Crear una cuenta de paciente" y "Gestionar mi cuenta". El padre le pasa
// los valores, los errores y la función que actualiza un campo:
// PersonFields(values = input, errors = submit.errors, onChange = ::update)
// =========================================================================
package fr.stahe.rdvmedecins.widgets
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.width
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t
val titles = listOf("Mr", "Mme", "Melle")
@Composable
fun PersonFields(values: Map<String, Any?>, errors: Map<String, String>, onChange: (String, String) -> Unit) {
Column {
DropdownList(
label = t("PERSONS.TITLE_LABEL"),
value = values["title"] as String,
choices = titles,
onChange = { onChange("title", it) },
error = errors["title"]?.let { t(it) },
modifier = Modifier.width(180.dp),
)
InputField(
label = "PERSONS.FIRSTNAME_LABEL",
maxLength = 20,
value = values["firstName"] as String,
onChange = { onChange("firstName", it) },
error = errors["firstName"],
)
InputField(
label = "PERSONS.LASTNAME_LABEL",
maxLength = 20,
value = values["lastName"] as String,
onChange = { onChange("lastName", it) },
error = errors["lastName"],
)
}
}
|
| // =========================================================================
// widgets/FormSubmit.kt - enviar un formulario al servidor
// -------------------------------------------------------------------------
// Todos los formularios de la aplicación siguen el mismo patrón que el
// ejemplo 25: no se verifica ninguna regla en el teléfono (viven
// en UN solo lugar, el servidor), y en caso de rechazo:
// - el error de cada campo (ApiError.fields) se muestra bajo el campo;
// - el mensaje general (ApiError.key) se muestra al pie de la pantalla.
// Esta clase agrupa estas acciones (es el Command del ejemplo 23,
// completado con los errores de los campos). Una pantalla crea uno por formulario:
//
// val submit = remember { FormSubmit(messages) }
// if (submit.send { api.register(input) }) { ... }
// InputField(..., error = submit.errors["lastName"])
// =========================================================================
package fr.stahe.rdvmedecins.widgets
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.state.Messages
class FormSubmit(private val messages: Messages) {
// el error de cada campo: una CLAVE de traducción
var errors by mutableStateOf(mapOf<String, String>())
private set
// los parámetros de los mensajes de error ({{min}}...), devueltos por el servidor
var params by mutableStateOf(mapOf<String, String>())
private set
var inProgress by mutableStateOf(false)
private set
// ejecuta el envío; devuelve true si tuvo éxito. En caso de ApiError, los
// errores se muestran y se devuelve false
suspend fun send(action: suspend () -> Unit): Boolean {
if (inProgress) return false // sin doble envío
errors = emptyMap()
params = emptyMap()
inProgress = true
try {
action()
return true
} catch (e: ApiError) {
messages.showApiError(e)
errors = e.fields
params = e.params
return false
} finally {
inProgress = false
}
}
// el usuario cambia un campo: su error desaparece
fun clearError(field: String) {
if (field in errors) errors = errors - field
}
}
|
El [Command] del ejemplo 23, con los errores de campo añadidos: todos los formularios de la aplicación lo utilizan.
| // =========================================================================
// widgets/Confirmation.kt - "¿Está seguro?"
// -------------------------------------------------------------------------
// Tomado del ejemplo 16. El mensaje es una CLAVE de traducción:
// if (confirmation.confirm("SCHEDULE.CANCEL_CONFIRM")) { ... }
// "No, volver" en lugar de "Cancelar": la pregunta a veces es "¿Cancelar esta
// cita?", y un botón "Cancelar" sería ambiguo en ese caso.
// Una nueva pregunta borra los mensajes de la acción anterior.
// =========================================================================
package fr.stahe.rdvmedecins.widgets
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
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.graphics.Color
import fr.stahe.rdvmedecins.state.Messages
import fr.stahe.rdvmedecins.i18n.t
import kotlinx.coroutines.CompletableDeferred
class Confirmation(private val messages: Messages) {
var question by mutableStateOf<String?>(null)
private set
private var pending: CompletableDeferred<Boolean>? = null
suspend fun confirm(key: String): Boolean {
messages.clear()
val waiting = CompletableDeferred<Boolean>()
pending = waiting
question = key
try {
return waiting.await()
} finally {
question = null
}
}
fun answer(yes: Boolean) {
pending?.complete(yes)
}
}
@Composable
fun rememberConfirmation(messages: Messages): Confirmation = remember { Confirmation(messages) }
@Composable
fun ConfirmDialog(confirmation: Confirmation) {
val key = confirmation.question ?: return
AlertDialog(
onDismissRequest = { confirmation.answer(false) },
title = { Text(t("CONFIRMATION.TITLE")) },
text = { Text(t(key)) },
dismissButton = { TextButton(onClick = { confirmation.answer(false) }) { Text(t("CONFIRMATION.NO")) } },
confirmButton = {
Button(
onClick = { confirmation.answer(true) },
colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFC62828)),
) { Text(t("CONFIRMATION.YES")) }
},
)
}
|
| // =========================================================================
// widgets/CaptchaField.kt - la imagen del captcha y el campo de entrada
// -------------------------------------------------------------------------
// Un componente de visualización: la imagen (svg), el botón "Otra imagen"
// (onReload), y el campo, CONTROLADO por el formulario padre (value,
// onChange). La imagen y su identificador los solicita al servidor
// la pantalla de inicio de sesión, que los necesita para enviar la respuesta.
// =========================================================================
package fr.stahe.rdvmedecins.widgets
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t
@Composable
fun CaptchaField(svg: String?, value: String, onChange: (String) -> Unit, onReload: () -> Unit, error: String? = null) {
Column {
Text(t("CAPTCHA.LABEL"), style = MaterialTheme.typography.bodySmall)
Row(verticalAlignment = Alignment.CenterVertically) {
Box(
contentAlignment = Alignment.Center,
modifier = Modifier
.size(160.dp, 54.dp)
.background(Color(0xFFF5F7FA), RoundedCornerShape(6.dp))
.border(1.dp, Color(0xFFE0E0E0), RoundedCornerShape(6.dp)),
) {
// description: lo que lee un lector de pantalla en lugar de la imagen
if (svg != null) SvgImage(svg, height = 50.dp, description = t("CAPTCHA.IMAGE_ALT"))
}
TextButton(onClick = onReload) {
Icon(Icons.Default.Refresh, contentDescription = null)
Text(t("CAPTCHA.NEW_IMAGE"))
}
}
InputField(label = "CAPTCHA.LABEL", help = "CAPTCHA.HELP", maxLength = 10, value = value, onChange = onChange, error = error)
}
}
|
| // =========================================================================
// widgets/SvgImage.kt (tomado de los ejemplos, common/SvgImage.kt) - dibujar una imagen SVG dada como texto
// -------------------------------------------------------------------------
// La imagen del captcha la genera el servidor, en formato SVG (un texto
// que describe un dibujo). Android no puede mostrarla por sí solo: la
// biblioteca AndroidSVG la dibuja en una imagen (un Bitmap), que
// Compose muestra con el componente Image.
// =========================================================================
package fr.stahe.rdvmedecins.widgets
import android.graphics.Bitmap
import android.graphics.Canvas
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.height
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import com.caverock.androidsvg.SVG
@Composable
fun SvgImage(svg: String, modifier: Modifier = Modifier, height: Dp = 50.dp, description: String? = null) {
// el dibujo solo se rehace si cambia el texto SVG (remember(svg))
val image = remember(svg) {
val document = SVG.getFromString(svg)
// dibujada 3 veces más grande que su tamaño "natural": una imagen nítida
val scale = 3f
val docWidth = (document.documentWidth.takeIf { it > 0 } ?: 150f)
val docHeight = (document.documentHeight.takeIf { it > 0 } ?: 50f)
val bitmap = Bitmap.createBitmap((docWidth * scale).toInt(), (docHeight * scale).toInt(), Bitmap.Config.ARGB_8888)
val canvas = Canvas(bitmap)
canvas.scale(scale, scale)
document.renderToCanvas(canvas)
bitmap.asImageBitmap()
}
Image(image, contentDescription = description, contentScale = ContentScale.Fit, modifier = modifier.height(height))
}
|
| // =========================================================================
// widgets/DropdownList.kt (tomado de los ejemplos, common/DropdownList.kt) - una lista desplegable lista para usar
// -------------------------------------------------------------------------
// Material 3 para Compose no tiene un componente "lista desplegable"
// todo en uno: se arma con tres elementos - ExposedDropdownMenuBox,
// un campo de texto de solo lectura y el menú ExposedDropdownMenu. Lo
// hacemos aquí una vez por todas (ejemplos 05 a 08, 24, 25):
//
// DropdownList("Country", value = country, choices = listOf("fr", "be", "ch"),
// text = { countryNames[it] }, onChange = { country = it })
//
// La función es GENÉRICA (<T>): las opciones pueden ser cadenas,
// números, médicos... text indica cómo MOSTRAR una opción. Una opción
// puede ser null ("— choose —") si T es un tipo "anulable" (Int?).
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.rdvmedecins.widgets
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuAnchorType
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.ExposedDropdownMenuDefaults
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
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
@Composable
fun <T> DropdownList(
label: String,
value: T,
choices: List<T>,
onChange: (T) -> Unit,
modifier: Modifier = Modifier,
text: (T) -> String = { it.toString() },
// un mensaje de error bajo el campo (ver ejemplos 07 y 25)
error: String? = null,
) {
// ¿está abierto el menú? un estado PROPIO de cada lista desplegable
var expanded by remember { mutableStateOf(false) }
ExposedDropdownMenuBox(expanded = expanded, onExpandedChange = { expanded = it }, modifier = modifier) {
// el campo que muestra la opción actual; menuAnchor lo convierte en el
// punto de anclaje del menú (tocarlo abre el menú)
OutlinedTextField(
value = text(value),
onValueChange = {},
readOnly = true,
singleLine = true,
label = { Text(label) },
trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
isError = error != null,
supportingText = if (error == null) null else { { Text(error) } },
modifier = Modifier.menuAnchor(ExposedDropdownMenuAnchorType.PrimaryNotEditable).fillMaxWidth(),
)
// el menú: una fila por opción
ExposedDropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
for (c in choices) {
DropdownMenuItem(
text = { Text(text(c)) },
onClick = {
onChange(c)
expanded = false
},
)
}
}
}
}
|
| // widgets/Tag.kt - una etiqueta de color (el "badge" de los otros clientes)
package fr.stahe.rdvmedecins.widgets
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
@Composable
fun Tag(text: String, color: Color) {
Text(
text,
color = Color.White,
fontSize = 12.sp,
fontWeight = FontWeight.Bold,
modifier = Modifier.background(color, RoundedCornerShape(6.dp)).padding(horizontal = 8.dp, vertical = 3.dp),
)
}
|
| // =========================================================================
// widgets/BookingDialog.kt - el diálogo de reserva de un horario
// -------------------------------------------------------------------------
// Un destino de tipo "dialog" de la navegación (Screens.Booking):
// se muestra ENCIMA de la agenda, con el fondo atenuado incluido, y el botón
// Atrás del teléfono lo cierra. Su ruta contiene todo lo que necesita:
// el médico, el día, el horario.
// Vuelve a leer la agenda desde el CACHÉ (sin solicitud: la agenda acaba de
// leerse) para encontrar en ella el horario y verificar que se puede reservar.
// Después de la reserva: un mensaje flash, el cierre y la invalidación
// del caché; la agenda, aún viva bajo el diálogo, se vuelve a leer sola.
// =========================================================================
package fr.stahe.rdvmedecins.widgets
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ScheduleSlot
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.state.isManager
import fr.stahe.rdvmedecins.state.isPatient
import fr.stahe.rdvmedecins.timeRange
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.navigation.Screens
import fr.stahe.rdvmedecins.pages.scheduleKey
import kotlinx.coroutines.launch
@Composable
fun BookingDialog(route: Screens.Booking, onClose: () -> Unit) {
val d = LocalDependencies.current
val u = d.session.user
var slot by remember { mutableStateOf<ScheduleSlot?>(null) }
// ADMIN / DOCTOR: los pacientes entre los que elegir
var clients by remember { mutableStateOf(listOf<Person>()) }
var clientId by remember { mutableStateOf<Int?>(null) }
var sending by remember { mutableStateOf(false) }
val scope = rememberCoroutineScope()
LaunchedEffect(Unit) {
try {
val schedule = d.cache.read(scheduleKey(route.doctorId, route.day)) { d.api.schedule(route.doctorId, route.day) }
// solo si este usuario puede reservar este horario
slot = schedule.slots.find { it.id == route.slotId && it.bookable }
if (slot == null) onClose()
if (u.isManager) clients = d.cache.read("clients") { d.api.list(PersonType.CLIENTS) }
} catch (e: ApiError) {
d.messages.showApiError(e)
}
}
fun confirm() {
val c = slot ?: return
scope.launch {
sending = true
try {
d.api.book(route.day, c.id, if (u.isManager) clientId else null)
d.messages.flash("SCHEDULE.BOOKED")
} catch (e: ApiError) {
if (e.key == "ERRORS.CHOOSE_PATIENT") {
// ningún paciente elegido: el diálogo sigue abierto
d.messages.showError(e.key)
sending = false
return@launch
}
// horario tomado mientras tanto, paciente que ya tiene una cita...:
// el mensaje se mostrará en la agenda, con el diálogo cerrado
d.messages.flash(e.key, e.params, success = false)
}
sending = false
onClose()
// el servidor es la referencia: la agenda (y el área del paciente) se volverán a leer
d.cache.invalidate("my-area")
d.cache.invalidate("schedule")
}
}
val c = slot ?: return
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(20.dp)) {
Text(t("BOOKING_DIALOG.TITLE"), style = MaterialTheme.typography.titleLarge)
Spacer(Modifier.height(12.dp))
Text(t("BOOKING_DIALOG.SLOT", mapOf("time" to timeRange(c))))
Spacer(Modifier.height(12.dp))
if (u.isPatient) {
// un paciente reserva para sí mismo: sin lista (y el servidor
// ignoraría de todos modos un posible clientId)
Text(
buildAnnotatedString {
append("${t("BOOKING_DIALOG.PATIENT_LABEL")}: ")
withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append(u?.name ?: "") }
},
)
} else {
val prompt = t("BOOKING_DIALOG.CHOOSE_PATIENT")
DropdownList(
label = t("BOOKING_DIALOG.PATIENT_LABEL"),
value = clientId,
choices = listOf<Int?>(null) + clients.map { it.id },
text = { i -> clients.find { it.id == i }?.label ?: prompt },
onChange = { clientId = it },
modifier = Modifier.fillMaxWidth(),
)
}
// un error (ningún paciente elegido): el panel de errores de la pantalla queda
// oculto bajo el diálogo, lo repetimos aquí
d.messages.error?.let { m ->
Text(t(m.key, m.params), color = androidx.compose.ui.graphics.Color(0xFFC62828), modifier = Modifier.padding(top = 8.dp))
}
Spacer(Modifier.height(20.dp))
Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp, androidx.compose.ui.Alignment.End)) {
TextButton(onClick = onClose) { Text(t("BOOKING_DIALOG.CANCEL")) }
Button(onClick = { confirm() }, enabled = !sending) { Text(t("BOOKING_DIALOG.CONFIRM")) }
}
}
}
}
|
- líneas 64–70: la agenda, vuelta a leer en CACHÉ (sin consulta: acaba de leerse), para encontrar el horario; los pacientes, para un administrador;
- líneas 76–98: la reserva: un mensaje emergente, el cierre de la ventana y la invalidación de la caché; la agenda, que permanece activa bajo la ventana, se vuelve a cargar automáticamente.
11.12. Las pantallas
11.12.1. pages/StartupPage.kt
| // =========================================================================
// pages/StartupPage.kt - la primera pantalla
// -------------------------------------------------------------------------
// El tiempo de preguntarle al servidor, una sola vez, quién ha iniciado sesión (GET
// /api/auth/me: la cookie del token puede haberse conservado de un uso
// anterior). Con sesión iniciada: la navegación (que observa la sesión) lleva a
// la página de inicio del rol; nadie: onNobody, la pantalla de inicio de sesión.
// =========================================================================
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import fr.stahe.rdvmedecins.LocalDependencies
@Composable
fun StartupPage(onNobody: () -> Unit) {
val session = LocalDependencies.current.session
LaunchedEffect(Unit) {
session.check()
if (session.user == null) onNobody()
}
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
}
|
11.12.2. pages/ErrorPage.kt
| // =========================================================================
// pages/ErrorPage.kt - la pantalla de error: 403 (rol insuficiente, ver
// navigation/Navigation.kt) o 404
// =========================================================================
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t
@Composable
fun ErrorPage(code: Int) {
Column(Modifier.padding(24.dp)) {
Text("${t("ERROR_PAGE.TITLE")} $code", style = MaterialTheme.typography.headlineMedium, color = Color(0xFFC62828))
Spacer(Modifier.height(8.dp))
Text(t(if (code == 403) "ERRORS.FORBIDDEN" else "ERRORS.NOT_FOUND"))
}
}
|
11.12.3. pages/LoginPage.kt
| // =========================================================================
// pages/LoginPage.kt - la pantalla de inicio de sesión
// -------------------------------------------------------------------------
// La misma pantalla que en los otros clientes: login, contraseña, captcha y
// un segundo botón "Crear una cuenta de paciente" que verifica el MISMO captcha
// antes de abrir la creación de cuenta.
// login: el campo está prellenado (justo después de la creación de una cuenta).
// Tras un inicio de sesión exitoso, esta pantalla NO navega por sí misma: la
// sesión cambia, y es la navegación la que sale de la pantalla de inicio de sesión
// (ver navigation/Navigation.kt).
// =========================================================================
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.autofill.ContentType
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.Captcha
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.CaptchaField
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.FormSubmit
import kotlinx.coroutines.launch
@Composable
fun LoginPage(login: String, onRegister: () -> Unit) {
val d = LocalDependencies.current
val submit = remember { FormSubmit(d.messages) }
// la entrada: un Map, campo -> valor; rememberSaveable: sobrevive a un
// cambio de idioma (la actividad se recrea)
var input by rememberSaveable { mutableStateOf(mapOf("login" to login, "password" to "", "captcha" to "")) }
var captcha by remember { mutableStateOf<Captcha?>(null) }
val scope = rememberCoroutineScope()
// una nueva imagen: hace falta después de CADA intento, porque una imagen solo
// se puede usar UNA VEZ (el servidor la olvida apenas la ha verificado)
suspend fun reloadCaptcha() {
captcha = try {
d.api.captcha()
} catch (e: Exception) {
null // servidor inalcanzable: el inicio de sesión fallará con un mensaje claro
}
}
LaunchedEffect(Unit) { reloadCaptcha() }
fun update(field: String, value: String) {
input = input + (field to value)
submit.clearError(field)
}
// los dos botones comparten esta secuencia: enviar y, en caso
// de fallo, mensaje de error y NUEVA imagen
fun attempt(action: suspend () -> Unit) {
scope.launch {
d.messages.clear()
if (!submit.send(action)) {
input = input + ("captcha" to "")
reloadCaptcha()
}
}
}
// si tiene éxito, no hay nada más que hacer aquí: la navegación cambia la pantalla
fun logIn() = attempt {
d.session.login(input.getValue("login").trim(), input.getValue("password"), captcha?.id ?: "", input.getValue("captcha"))
}
fun createAccount() = attempt {
d.api.registrationAccess(captcha?.id ?: "", input.getValue("captcha"))
onRegister()
}
Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp)) {
Text(t("LOGIN.TITLE"), style = MaterialTheme.typography.headlineSmall)
Spacer(Modifier.height(12.dp))
// autofillType: el administrador de contraseñas del teléfono puede llenar el formulario
InputField(
label = "LOGIN.LOGIN_LABEL",
value = input.getValue("login"),
onChange = { update("login", it) },
error = submit.errors["login"],
autofillType = ContentType.Username,
)
InputField(
label = "LOGIN.PASSWORD_LABEL",
secret = true,
value = input.getValue("password"),
onChange = { update("password", it) },
error = submit.errors["password"],
autofillType = ContentType.Password,
)
CaptchaField(
svg = captcha?.svg,
value = input.getValue("captcha"),
onChange = { update("captcha", it) },
onReload = { scope.launch { reloadCaptcha() } },
error = submit.errors["captcha"],
)
Spacer(Modifier.height(8.dp))
Button(onClick = { logIn() }, enabled = !submit.inProgress, modifier = Modifier.fillMaxWidth()) { Text(t("LOGIN.SUBMIT")) }
Spacer(Modifier.height(12.dp))
OutlinedButton(onClick = { createAccount() }, enabled = !submit.inProgress, modifier = Modifier.fillMaxWidth()) {
Text(t("LOGIN.CREATE_ACCOUNT"))
}
Text(
t("LOGIN.CREATE_ACCOUNT_HELP"),
textAlign = TextAlign.Center,
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.fillMaxWidth().padding(top = 4.dp),
)
Spacer(Modifier.height(16.dp))
DemoAccounts()
}
}
// las cuentas de demostración
@Composable
private fun DemoAccounts() {
val style = MaterialTheme.typography.bodySmall
Text(t("LOGIN.DEMO_ACCOUNTS"), style = style, color = Color.DarkGray)
for ((accounts, key) in listOf(
"admin" to "LOGIN.DEMO_ADMIN",
"pelissier, tatou, dupont" to "LOGIN.DEMO_DOCTOR",
"martin, durand, bistrou, german" to "LOGIN.DEMO_USER",
)) {
Text(
buildAnnotatedString {
append("• ")
withStyle(SpanStyle(fontFamily = FontFamily.Monospace)) { append(accounts) }
append(" - ${t(key)}")
},
style = style,
color = Color.DarkGray,
)
}
}
|
- línea 32: la entrada, un campo [Map] campo → valor, almacenado mediante [rememberSaveable]: sobrevive a un cambio de idioma;
- líneas 61–70: una nueva imagen después de CADA intento: una imagen se usa una sola vez;
- línea 89: si tiene éxito, no hay nada más que hacer: la sesión cambia y la navegación abandona la pantalla de inicio de sesión.
11.12.4. pages/SchedulePage.kt
| // =========================================================================
// pages/SchedulePage.kt - la pantalla de la agenda
// -------------------------------------------------------------------------
// Tres bloques, como en los otros clientes:
// 1. la elección del médico y del día;
// 2. la agenda de este médico en ese día;
// 3. el diálogo de reserva de un horario: otra ruta,
// Screens.Booking, mostrada encima (ver BookingDialog.kt).
//
// TODO el estado de la pantalla está en su RUTA: Screens.Schedule(doctorId, day).
// La pantalla DEDUCE de ella lo que muestra, y las acciones del usuario
// cambian la ruta (onView, onBook); el botón Atrás del teléfono
// cierra el diálogo de reserva.
//
// Lo que cada uno ve y puede hacer lo decide el SERVIDOR (campos
// patient, mine, bookable, appointmentId de cada horario): la pantalla se limita a
// mostrarlo. Un paciente ni siquiera recibe el nombre de los otros pacientes.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.DatePicker
import androidx.compose.material3.DatePickerDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberDatePickerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.Schedule
import fr.stahe.rdvmedecins.api.ScheduleSlot
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.today
import fr.stahe.rdvmedecins.fromMillis
import fr.stahe.rdvmedecins.isValidDate
import fr.stahe.rdvmedecins.timeRange
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.longDate
import fr.stahe.rdvmedecins.toMillis
import fr.stahe.rdvmedecins.widgets.Tag
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.DropdownList
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch
// la clave de la agenda de un médico en un día dado, en el caché
fun scheduleKey(doctorId: Int?, day: String) = "schedule/$doctorId/$day"
@Composable
fun SchedulePage(
doctorId: Int?,
day: String?, // tal cual en la ruta: quizá inválido
onView: (Int?, String) -> Unit,
onBook: (Int?, String, Int) -> Unit,
onMyArea: () -> Unit,
) {
val d = LocalDependencies.current
val user = d.session.user
val confirmation = rememberConfirmation(d.messages)
val scope = rememberCoroutineScope()
// el día: el de la ruta si es válido, de lo contrario hoy
val invalidDay = day != null && !isValidDate(day)
val theDay = if (day != null && !invalidDay) day else today()
var doctors by remember { mutableStateOf(listOf<Person>()) }
// la agenda (null mientras no haya llegado, o si no existe ninguna)
var schedule by remember { mutableStateOf<Schedule?>(null) }
var loading by remember { mutableStateOf(false) }
// los médicos: se leen una vez (caché); un error se muestra al pie de la pantalla
LaunchedEffect(Unit) {
try {
doctors = d.cache.read("doctors") { d.api.list(PersonType.DOCTORS) }
} catch (e: ApiError) {
d.messages.showApiError(e)
}
if (invalidDay) d.messages.showError("ERRORS.INVALID_DATE")
}
// la agenda: se vuelve a leer si cambia la ruta (otro médico, otro día) o si el
// caché se invalida (reserva, cancelación: cambia d.cache.version).
// Sin un médico en la ruta, un DOCTOR ve SU agenda (el servidor
// la encuentra a partir del token); los demás no ven nada
val hasSchedule = !invalidDay && (doctorId != null || user?.role == Role.DOCTOR)
LaunchedEffect(doctorId, theDay, d.cache.version) {
if (!hasSchedule) {
schedule = null
return@LaunchedEffect
}
loading = true
try {
schedule = d.cache.read(scheduleKey(doctorId, theDay)) { d.api.schedule(doctorId, theDay) }
} catch (e: ApiError) {
schedule = null
d.messages.showApiError(e)
}
loading = false
}
// el servidor es la referencia: tras una cancelación, la agenda se vuelve a leer
// (y el área del paciente, que muestra su cita)
fun cancel(c: ScheduleSlot) {
val appointmentId = c.appointmentId ?: return
scope.launch {
if (!confirmation.confirm("SCHEDULE.CANCEL_CONFIRM")) return@launch
try {
d.api.cancelAppointment(appointmentId)
d.messages.showSuccess("SCHEDULE.CANCELLED")
} catch (e: ApiError) {
d.messages.showApiError(e)
}
d.cache.invalidate("my-area")
d.cache.invalidate("schedule")
}
}
val a = schedule
// el médico mostrado: el de la ruta, o el de la agenda recibida (DOCTOR)
val shownId = doctorId ?: a?.doctor?.id
Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(12.dp)) {
// 1. la elección del médico y del día. key: si la ruta cambia, el
// formulario se recrea y parte de nuevo con los nuevos valores
androidx.compose.runtime.key(shownId, theDay) {
DoctorDayPicker(doctors = doctors, doctorId = shownId, day = theDay, onView = onView)
}
// paciente que ya tiene una cita próxima: por qué no hay botón "Reservar"
a?.info?.let { info ->
Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFE1F5FE)), modifier = Modifier.padding(top = 8.dp)) {
ListItem(
colors = androidx.compose.material3.ListItemDefaults.colors(containerColor = Color.Transparent),
headlineContent = { Text(t(info)) },
trailingContent = { TextButton(onClick = onMyArea) { Text(t("APP.MENU_MY_AREA")) } },
)
}
}
Spacer(Modifier.height(8.dp))
when {
loading && a == null -> Box(Modifier.fillMaxWidth().padding(24.dp), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
a != null -> ScheduleView(
schedule = a,
// "Reservar" cambia la RUTA: se abre el diálogo de reserva
onBook = { c -> onBook(shownId, theDay, c.id) },
onCancel = ::cancel,
)
else -> Text(t("SCHEDULE.EMPTY_STATE"), Modifier.padding(16.dp))
}
}
ConfirmDialog(confirmation)
}
// -------------------------------------------------------------------------
// 1. la elección del médico y del día: un formulario pequeño, cuyo estado
// solo es útil antes del envío. PARTE con los valores de la ruta.
// -------------------------------------------------------------------------
@Composable
private fun DoctorDayPicker(doctors: List<Person>, doctorId: Int?, day: String, onView: (Int?, String) -> Unit) {
var id by rememberSaveable { mutableStateOf(doctorId) }
var theDay by rememberSaveable { mutableStateOf(day) }
var calendar by remember { mutableStateOf(false) }
val language = LocalTranslations.current.language
// el médico elegido debe estar en la lista (de lo contrario: ninguno)
val knownId = id.takeIf { i -> doctors.any { it.id == i } }
// t() es una función @Composable: traducimos ANTES de la lambda de texto, que no lo es
val prompt = t("DOCTOR_DAY_PICKER.CHOOSE_DOCTOR")
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
DropdownList(
label = t("DOCTOR_DAY_PICKER.DOCTOR_LABEL"),
value = knownId,
choices = listOf<Int?>(null) + doctors.map { it.id },
text = { i -> doctors.find { it.id == i }?.label ?: prompt },
onChange = { id = it },
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(8.dp))
// el día: un campo de solo lectura; al tocarlo se abre el calendario
Box {
OutlinedTextField(
value = longDate(theDay, language),
onValueChange = {},
readOnly = true,
label = { Text(t("DOCTOR_DAY_PICKER.DAY_LABEL")) },
trailingIcon = { Icon(Icons.Default.DateRange, contentDescription = t("DOCTOR_DAY_PICKER.CHOOSE_DAY")) },
modifier = Modifier.fillMaxWidth(),
)
// una superficie transparente, encima del campo, que recibe el toque
Box(Modifier.matchParentSize().clickable { calendar = true })
}
Spacer(Modifier.height(12.dp))
Button(onClick = { onView(knownId, theDay) }, enabled = knownId != null, modifier = Modifier.fillMaxWidth()) {
Text(t("DOCTOR_DAY_PICKER.VIEW_SCHEDULE"))
}
}
}
if (calendar) {
val state = rememberDatePickerState(initialSelectedDateMillis = toMillis(theDay))
DatePickerDialog(
onDismissRequest = { calendar = false },
// los textos OK / Cancelar de Android, en el idioma de la aplicación
confirmButton = {
TextButton(onClick = {
state.selectedDateMillis?.let { theDay = fromMillis(it) }
calendar = false
}) { Text(stringResource(android.R.string.ok)) }
},
dismissButton = { TextButton(onClick = { calendar = false }) { Text(stringResource(android.R.string.cancel)) } },
) { DatePicker(state = state) }
}
}
// -------------------------------------------------------------------------
// 2. la agenda
// -------------------------------------------------------------------------
@Composable
private fun ScheduleView(schedule: Schedule, onBook: (ScheduleSlot) -> Unit, onCancel: (ScheduleSlot) -> Unit) {
val language = LocalTranslations.current.language
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(vertical = 8.dp)) {
ListItem(
headlineContent = { Text("${t("SCHEDULE.TITLE_PREFIX")} ${longDate(schedule.day, language)}", style = MaterialTheme.typography.titleMedium) },
supportingContent = { Text(schedule.doctor.label) },
)
if (schedule.slots.isEmpty()) Text(t("SCHEDULE.NO_SLOTS"), Modifier.padding(16.dp))
for (c in schedule.slots) {
HorizontalDivider()
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier
.fillMaxWidth()
// los horarios reservables se colorean ligeramente
.background(if (c.bookable) Color(0xFFE8F5E9) else Color.Transparent)
.padding(horizontal = 12.dp, vertical = 6.dp),
) {
Text(timeRange(c), fontWeight = FontWeight.Medium, modifier = Modifier.width(96.dp))
Box(Modifier.weight(1f)) {
when {
c.free -> Tag(t("SCHEDULE.FREE"), Color(0xFF2E7D32))
c.patient != null -> Tag(c.patient.label, if (c.mine) Color(0xFF3F51B5) else Color(0xFF757575))
else -> Tag(t("SCHEDULE.BOOKED_BY_OTHER"), Color(0xFF757575))
}
}
when {
c.bookable -> OutlinedButton(onClick = { onBook(c) }) { Text(t("SCHEDULE.BOOK")) }
c.appointmentId != null -> OutlinedButton(
onClick = { onCancel(c) },
colors = ButtonDefaults.outlinedButtonColors(contentColor = Color(0xFFC62828)),
) { Text(t("SCHEDULE.CANCEL_APPOINTMENT")) }
}
}
}
}
}
}
|
- línea 91: la clave de la agenda en la caché;
- líneas 115–117: médicos, leídos una sola vez (caché);
- líneas 129–136: la agenda, vuelta a leer si cambia la ruta o si se invalida la caché;
- líneas 149–157: cancelación: confirmación, solicitud, invalidación de la caché;
- líneas 200–230: selección del médico y del día; el día es un campo de solo lectura, cubierto por una capa transparente que abre el calendario;
- líneas 259–274: la agenda: lo que cada usuario ve y puede hacer lo determina el SERVIDOR.
11.12.5. pages/PatientAreaPage.kt
| // =========================================================================
// pages/PatientAreaPage.kt - "Mi área" (rol USER)
// -------------------------------------------------------------------------
// La pantalla de inicio del paciente, justo después de iniciar sesión:
// - dos opciones: [Gestionar mi cuenta] y [Ver una agenda];
// - su cita próxima, si la tiene, con los medios para cancelarla.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
import androidx.compose.material.icons.filled.AccountCircle
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.MyArea
import fr.stahe.rdvmedecins.timeRange
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.longDate
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch
@Composable
fun PatientAreaPage(onMyAccount: () -> Unit, onSchedule: (Int?, String?) -> Unit) {
val d = LocalDependencies.current
val language = LocalTranslations.current.language
val confirmation = rememberConfirmation(d.messages)
val scope = rememberCoroutineScope()
var area by remember { mutableStateOf<MyArea?>(null) }
LaunchedEffect(d.cache.version) {
try {
area = d.cache.read("my-area") { d.api.myArea() }
} catch (e: ApiError) {
d.messages.showApiError(e)
}
}
fun cancel(appointmentId: Int) {
scope.launch {
if (!confirmation.confirm("SCHEDULE.CANCEL_CONFIRM")) return@launch
try {
d.api.cancelAppointment(appointmentId)
d.messages.showSuccess("SCHEDULE.CANCELLED")
} catch (e: ApiError) {
d.messages.showApiError(e)
}
// el área Y las agendas han cambiado
d.cache.invalidate("my-area")
d.cache.invalidate("schedule")
}
}
val e = area
if (e == null) {
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
return
}
Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(12.dp)) {
Text(t("AREA.HELLO", mapOf("name" to e.patient.label)), style = MaterialTheme.typography.headlineSmall, modifier = Modifier.padding(4.dp))
Option(Icons.Default.AccountCircle, t("AREA.MANAGE_ACCOUNT"), t("AREA.MANAGE_ACCOUNT_HELP"), onMyAccount)
Option(Icons.Default.DateRange, t("AREA.VIEW_SCHEDULE"), t("AREA.VIEW_SCHEDULE_HELP")) { onSchedule(null, null) }
Spacer(Modifier.height(8.dp))
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(12.dp)) {
Text(t("AREA.MY_APPOINTMENT"), style = MaterialTheme.typography.titleMedium)
// normalmente solo una (regla "una cita próxima a la vez"),
// pero la pantalla puede mostrar varias
for (appt in e.appointments) {
Spacer(Modifier.height(8.dp))
Text("${longDate(appt.day, language)}, ${timeRange(appt.slot)}", fontWeight = FontWeight.SemiBold)
Text(appt.doctor.label)
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
// la agenda del médico en ese día: el paciente ve allí su nombre
TextButton(onClick = { onSchedule(appt.doctor.id, appt.day) }) { Text(t("AREA.SEE_IN_SCHEDULE")) }
OutlinedButton(
onClick = { cancel(appt.id) },
colors = ButtonDefaults.outlinedButtonColors(contentColor = Color(0xFFC62828)),
) { Text(t("AREA.CANCEL_APPOINTMENT")) }
}
}
if (e.appointments.isEmpty()) Text(t("AREA.NO_APPOINTMENT"), color = Color.Gray, modifier = Modifier.padding(top = 8.dp))
}
}
}
ConfirmDialog(confirmation)
}
// una "tarjeta" de opción, que se toca para abrir una pantalla
@Composable
private fun Option(icon: ImageVector, title: String, help: String, onClick: () -> Unit) {
Card(Modifier.fillMaxWidth().padding(vertical = 4.dp).clickable(onClick = onClick)) {
ListItem(
leadingContent = { Icon(icon, contentDescription = null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(32.dp)) },
headlineContent = { Text(title, style = MaterialTheme.typography.titleMedium) },
supportingContent = { Text(help) },
trailingContent = { Icon(Icons.AutoMirrored.Filled.KeyboardArrowRight, contentDescription = null) },
)
}
}
|
11.12.6. pages/PersonsConfig.kt
| // =========================================================================
// pages/PersonsConfig.kt - ¿médicos o clientes?
// -------------------------------------------------------------------------
// Las pantallas de gestión de los médicos y de los clientes son IDÉNTICAS: la misma
// lista, el mismo formulario. Las escribimos UNA SOLA VEZ (PersonsPage.kt,
// PersonFormPage.kt); solo cambian la dirección de la API y las
// claves de las etiquetas, descritas aquí. La ruta le pasa el tipo a cada pantalla.
// =========================================================================
package fr.stahe.rdvmedecins.pages
import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.PersonType
data class PersonKeys(
val title: String, // "Doctors"
val add: String, // "Add a doctor"
val edit: String, // "Edit a doctor"
val empty: String, // "No doctors."
val confirmDelete: String,
val added: String, // "Doctor {{name}} has been added (login: {{login}})."
val updated: String,
val deleted: String,
val notFound: String, // el registro ha sido eliminado mientras tanto
)
// las claves de un tipo: escritas una sola vez, gracias al prefijo "DOCTORS." o "CLIENTS."
fun keys(type: PersonType): PersonKeys {
val p = if (type == PersonType.DOCTORS) "DOCTORS" else "CLIENTS"
return PersonKeys(
title = "$p.TITLE",
add = "$p.ADD",
edit = "$p.EDIT",
empty = "$p.EMPTY",
confirmDelete = "$p.DELETE_CONFIRM",
added = "$p.ADDED",
updated = "$p.UPDATED",
deleted = "$p.DELETED",
notFound = if (type == PersonType.DOCTORS) "ERRORS.DOCTOR_NOT_FOUND" else "ERRORS.PATIENT_NOT_FOUND",
)
}
// {{name}} y {{login}} de los mensajes "agregado / actualizado / eliminado"
fun messageParams(p: Person) = mapOf("name" to "${p.firstName} ${p.lastName}", "login" to (p.login ?: ""))
|
11.12.7. pages/PersonsPage.kt
| // =========================================================================
// pages/PersonsPage.kt - la lista de los médicos O de los clientes (ADMIN)
// -------------------------------------------------------------------------
// Una sola pantalla para ambos: el tipo (médicos o clientes) llega por la
// ruta; las etiquetas propias de cada uno están en PersonsConfig.kt.
// En un teléfono, una tabla de cinco columnas no cabe: una fila de lista
// por persona (nombre, login), con sus dos botones; el botón redondo
// "+" (FloatingActionButton) agrega una persona.
// La lista es un LazyColumn: solo se construyen las filas visibles.
// =========================================================================
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExtendedFloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch
@Composable
fun PersonsPage(type: PersonType, onAdd: () -> Unit, onEdit: (Int) -> Unit) {
val d = LocalDependencies.current
val c = keys(type)
val confirmation = rememberConfirmation(d.messages)
val scope = rememberCoroutineScope()
// null: aún no cargado
var list by remember(type) { mutableStateOf<List<Person>?>(null) }
var failed by remember(type) { mutableStateOf(false) }
// se vuelve a leer si cambia el tipo o si el caché se invalida
LaunchedEffect(type, d.cache.version) {
try {
list = d.cache.read(type.path) { d.api.list(type) }
} catch (e: ApiError) {
failed = true
d.messages.showApiError(e)
}
}
fun delete(p: Person) {
scope.launch {
if (!confirmation.confirm(c.confirmDelete)) return@launch
try {
d.api.delete(type, p.id)
d.messages.showSuccess(c.deleted, messageParams(p))
} catch (e: ApiError) {
// un médico que todavía tiene citas: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
d.messages.showApiError(e)
}
d.cache.invalidate(type.path)
}
}
Box(Modifier.fillMaxSize()) {
val l = list
if (l == null) {
// aún no cargado (o la carga falló: el mensaje está al pie de la pantalla)
if (!failed) CircularProgressIndicator(Modifier.align(Alignment.Center))
} else {
// un poco de espacio al final, para no ocultar la última fila bajo el botón flotante
LazyColumn(contentPadding = PaddingValues(start = 8.dp, top = 8.dp, end = 8.dp, bottom = 88.dp)) {
item { Text(t(c.title), style = MaterialTheme.typography.headlineSmall, modifier = Modifier.padding(8.dp)) }
if (l.isEmpty()) item { ListItem(headlineContent = { Text(t(c.empty)) }) }
// una fila por persona; key: la identidad de la fila
items(l, key = { it.id }) { p ->
Card(Modifier.padding(vertical = 4.dp)) {
ListItem(
leadingContent = {
Box(Modifier.size(40.dp).background(MaterialTheme.colorScheme.primaryContainer, CircleShape), contentAlignment = Alignment.Center) {
Text("${p.firstName.first()}${p.lastName.first()}")
}
},
headlineContent = { Text(p.label) },
supportingContent = { Text(p.login ?: "", fontFamily = FontFamily.Monospace) },
trailingContent = {
Row {
IconButton(onClick = { onEdit(p.id) }) { Icon(Icons.Default.Edit, contentDescription = t("PERSONS.EDIT")) }
IconButton(onClick = { delete(p) }) {
Icon(Icons.Outlined.Delete, contentDescription = t("PERSONS.DELETE"), tint = Color(0xFFC62828))
}
}
},
)
}
}
}
}
ExtendedFloatingActionButton(
onClick = onAdd,
icon = { Icon(Icons.Default.Add, contentDescription = null) },
text = { Text(t(c.add)) },
modifier = Modifier.align(Alignment.BottomEnd).padding(16.dp),
)
}
ConfirmDialog(confirmation)
}
|
- línea 97: un [LazyColumn]: solo se generan las líneas visibles (equivalente a [ListView.builder] de [Flutter]); [contentPadding] deja espacio debajo de la última línea para el botón flotante;
- línea 124: el botón flotante ([ExtendedFloatingActionButton]) que agrega una persona.
11.12.8. pages/PersonFormPage.kt
| // =========================================================================
// pages/PersonFormPage.kt - creación O actualización de un médico
// o de un cliente (ADMIN)
// -------------------------------------------------------------------------
// Screens.Person(DOCTORS) -> creación (sin id)
// Screens.Person(DOCTORS, id = 3) -> actualización
// Dos componentes:
// - PersonFormPage lee el registro por actualizar (si lo hay);
// - Form solo se muestra una vez leído el registro: PARTE de
// sus valores (estado inicial), sin tener que copiarlos después.
// Aquí no se verifica ninguna regla: el servidor valida todo, y sus errores
// se muestran bajo los campos (ver widgets/FormSubmit.kt).
// La VERSIÓN leída con el registro vuelve con la actualización: si otro
// ADMIN lo ha actualizado mientras tanto, el servidor responde 409 CONCURRENT_UPDATE.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.FormData
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.PersonFields
import fr.stahe.rdvmedecins.widgets.FormSubmit
import kotlinx.coroutines.launch
private val empty = mapOf("title" to "Mr", "firstName" to "", "lastName" to "", "login" to "", "password" to "")
@Composable
fun PersonFormPage(type: PersonType, id: Int?, onList: () -> Unit) {
val d = LocalDependencies.current
// los valores iniciales: vacíos (creación), o los del registro leído
var initial by remember { mutableStateOf<FormData?>(if (id == null) empty else null) }
if (id != null) {
LaunchedEffect(id) {
try {
// SIN caché: el registro debe estar actualizado (de lo contrario el formulario
// partiría con una versión desactualizada: 409 CONCURRENT_UPDATE)
val p = d.api.read(type, id)
initial = mapOf("title" to p.title, "firstName" to p.firstName, "lastName" to p.lastName, "login" to (p.login ?: ""), "password" to "", "version" to p.version)
} catch (e: ApiError) {
// registro que no existe (eliminado mientras tanto...): de vuelta a la lista
d.messages.flash(e.key, e.params, success = false)
onList()
}
}
}
val start = initial
if (start == null) {
Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
} else {
Form(type, id, start, onList)
}
}
// el formulario en sí
@Composable
private fun Form(type: PersonType, id: Int?, initial: FormData, onList: () -> Unit) {
val d = LocalDependencies.current
val c = keys(type)
val creating = id == null
val submit = remember { FormSubmit(d.messages) }
// una COPIA editable de los valores iniciales
var input by rememberSaveable { mutableStateOf(initial) }
val scope = rememberCoroutineScope()
fun update(field: String, value: String) {
input = input + (field to value)
submit.clearError(field)
}
fun save() {
scope.launch {
val succeeded = submit.send {
val p = if (id == null) d.api.add(type, input) else d.api.update(type, id, input)
d.messages.flash(if (creating) c.added else c.updated, messageParams(p))
}
val key = d.messages.error?.key
if (succeeded) {
d.cache.invalidate(type.path) // la lista ha cambiado
onList()
} else if (key == c.notFound) {
// eliminado mientras tanto por otro ADMIN: de vuelta a la lista
d.messages.flash(key, success = false)
onList()
}
}
}
Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp)) {
Text(t(if (creating) c.add else c.edit), style = MaterialTheme.typography.headlineSmall)
Spacer(Modifier.height(8.dp))
PersonFields(values = input, errors = submit.errors, onChange = ::update)
Spacer(Modifier.height(16.dp))
Text(t("PERSONS.ACCOUNT_SECTION"), style = MaterialTheme.typography.titleSmall)
InputField(
label = "PERSONS.LOGIN_LABEL",
maxLength = 30,
value = input["login"] as String,
onChange = { update("login", it) },
error = submit.errors["login"],
help = if (creating) "PERSONS.LOGIN_HELP_CREATE" else "PERSONS.LOGIN_HELP_EDIT",
)
// nunca prellenado: la contraseña nunca regresa del servidor
InputField(
label = "PERSONS.PASSWORD_LABEL",
secret = true,
maxLength = 72,
value = input["password"] as String,
onChange = { update("password", it) },
error = submit.errors["password"],
params = submit.params,
help = if (creating) "PERSONS.PASSWORD_HELP_CREATE" else "PERSONS.PASSWORD_HELP_EDIT",
)
Spacer(Modifier.height(16.dp))
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Button(onClick = { save() }, enabled = !submit.inProgress) { Text(t("PERSONS.SAVE")) }
OutlinedButton(onClick = onList) { Text(t("PERSONS.BACK")) }
}
}
}
|
11.12.9. pages/RegisterPage.kt
| // =========================================================================
// pages/RegisterPage.kt - "Crear una cuenta de paciente"
// -------------------------------------------------------------------------
// Solo llegamos aquí después de haber copiado el captcha de la pantalla de inicio de sesión
// (botón "Crear una cuenta de paciente"): el servidor ha emitido entonces un
// pase (una cookie). La pantalla lo verifica apenas se abre (GET
// /api/register/access): sin pase, de vuelta al inicio de sesión.
// Los mismos campos que el formulario del ADMIN, pero el login y la
// contraseña son obligatorios, con confirmación.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.autofill.ContentType
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.PersonFields
import fr.stahe.rdvmedecins.widgets.FormSubmit
import kotlinx.coroutines.launch
// longitud mínima de una contraseña elegida por un paciente: el mismo valor
// que el servidor (que también envía {min} con el error PASSWORD_TOO_SHORT)
const val PASSWORD_MIN = "6"
@Composable
fun RegisterPage(onLogin: (String) -> Unit) {
val d = LocalDependencies.current
val submit = remember { FormSubmit(d.messages) }
var input by rememberSaveable {
mutableStateOf(mapOf("title" to "Mr", "firstName" to "", "lastName" to "", "login" to "", "password" to "", "confirmation" to ""))
}
val scope = rememberCoroutineScope()
// el guardia PROPIO de esta pantalla: sin pase, de vuelta al inicio de sesión
LaunchedEffect(Unit) {
val valid = runCatching { d.api.registrationAccessStatus() }.getOrDefault(false)
if (!valid) {
d.messages.flash("ERRORS.CAPTCHA_BEFORE_ACCOUNT", success = false)
onLogin("")
}
}
fun update(field: String, value: String) {
input = input + (field to value)
submit.clearError(field)
}
fun create() {
scope.launch {
var login = ""
val succeeded = submit.send { login = d.api.register(input) }
if (succeeded) {
// de vuelta a la pantalla de inicio de sesión, con el login prellenado
d.messages.flash("REGISTRATION.DONE", mapOf("login" to login))
onLogin(login)
} else if (d.messages.error?.key == "ERRORS.CAPTCHA_BEFORE_ACCOUNT") {
// pase expirado (15 minutos): de vuelta al captcha
d.messages.flash("ERRORS.CAPTCHA_BEFORE_ACCOUNT", success = false)
onLogin("")
}
}
}
// los parámetros del mensaje de ayuda Y de los errores de contraseña
val passwordParams = mapOf("min" to PASSWORD_MIN) + submit.params
Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp)) {
Text(t("REGISTRATION.TITLE"), style = MaterialTheme.typography.headlineSmall)
Text(t("REGISTRATION.INTRO"), color = Color.Gray)
Spacer(Modifier.height(8.dp))
PersonFields(values = input, errors = submit.errors, onChange = ::update)
Spacer(Modifier.height(16.dp))
Text(t("PERSONS.ACCOUNT_SECTION"), style = MaterialTheme.typography.titleSmall)
InputField(
label = "PERSONS.LOGIN_LABEL",
maxLength = 30,
value = input.getValue("login"),
onChange = { update("login", it) },
error = submit.errors["login"],
help = "REGISTRATION.LOGIN_HELP",
autofillType = ContentType.NewUsername,
)
InputField(
label = "PERSONS.PASSWORD_LABEL",
secret = true,
maxLength = 72,
value = input.getValue("password"),
onChange = { update("password", it) },
error = submit.errors["password"],
params = passwordParams,
help = "REGISTRATION.PASSWORD_HELP",
autofillType = ContentType.NewPassword,
)
InputField(
label = "ACCOUNT.CONFIRMATION_LABEL",
secret = true,
maxLength = 72,
value = input.getValue("confirmation"),
onChange = { update("confirmation", it) },
error = submit.errors["confirmation"],
)
Spacer(Modifier.height(16.dp))
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Button(onClick = { create() }, enabled = !submit.inProgress) { Text(t("REGISTRATION.SUBMIT")) }
OutlinedButton(onClick = { onLogin("") }) { Text(t("REGISTRATION.BACK_TO_LOGIN")) }
}
}
}
|
11.12.10. pages/MyAccountPage.kt
| // =========================================================================
// pages/MyAccountPage.kt - "Gestionar mi cuenta" (rol USER)
// -------------------------------------------------------------------------
// Dos formularios independientes:
// 1. la actualización (identidad, login, nueva contraseña opcional);
// 2. la eliminación de la cuenta, que también cancela sus citas.
// Ambos exigen la contraseña ACTUAL (verificada por el servidor).
// Dos formularios, por lo tanto dos FormSubmit (dos conjuntos de errores). Al
// igual que en el formulario de personas, la actualización solo se muestra una vez
// leída la cuenta, y parte con sus valores.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)
package fr.stahe.rdvmedecins.pages
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedCard
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.MyAccount
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.PersonFields
import fr.stahe.rdvmedecins.widgets.FormSubmit
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch
@Composable
fun MyAccountPage(onMyArea: () -> Unit) {
val d = LocalDependencies.current
// se vuelve a leer en cada visita, sin caché: su versión debe estar actualizada
var account by remember { mutableStateOf<MyAccount?>(null) }
LaunchedEffect(Unit) {
try {
account = d.api.myAccount()
} catch (e: ApiError) {
d.messages.showApiError(e)
}
}
Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(12.dp)) {
val c = account
if (c == null) {
Box(Modifier.fillMaxWidth().padding(24.dp), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
} else {
EditAccount(c, onMyArea)
}
Spacer(Modifier.height(12.dp))
DeleteAccount()
}
}
// -------------------------------------------------------------------------
// 1. la actualización
// -------------------------------------------------------------------------
@Composable
private fun EditAccount(account: MyAccount, onMyArea: () -> Unit) {
val d = LocalDependencies.current
val submit = remember { FormSubmit(d.messages) }
val scope = rememberCoroutineScope()
var input by rememberSaveable {
mutableStateOf(
mapOf<String, Any?>(
"title" to account.title,
"firstName" to account.firstName,
"lastName" to account.lastName,
"login" to account.login,
"password" to "",
"confirmation" to "",
"currentPassword" to "",
"version" to account.version,
),
)
}
fun update(field: String, value: String) {
input = input + (field to value)
submit.clearError(field)
}
fun save() {
scope.launch {
val succeeded = submit.send {
// el servidor ha emitido un NUEVO token (nombre, login): la barra superior debe seguirlo
d.session.update(d.api.updateMyAccount(input))
d.messages.flash("MY_ACCOUNT.UPDATED")
}
if (succeeded) {
d.cache.invalidate("my-area")
onMyArea()
} else {
// nunca queda una contraseña en el campo tras un envío rechazado;
// el valor se cambia SIN pasar por update(), para no
// borrar el error que el servidor acaba de asociarle
input = input + ("currentPassword" to "")
}
}
}
Card(Modifier.fillMaxWidth()) {
Column(Modifier.padding(16.dp)) {
Text(t("MY_ACCOUNT.TITLE"), style = MaterialTheme.typography.titleLarge)
PersonFields(values = input, errors = submit.errors, onChange = ::update)
Spacer(Modifier.height(12.dp))
Text(t("PERSONS.ACCOUNT_SECTION"), style = MaterialTheme.typography.titleSmall)
InputField("PERSONS.LOGIN_LABEL", input["login"] as String, { update("login", it) }, submit.errors["login"], maxLength = 30)
InputField(
label = "MY_ACCOUNT.NEW_PASSWORD_LABEL",
secret = true,
maxLength = 72,
value = input["password"] as String,
onChange = { update("password", it) },
error = submit.errors["password"],
params = submit.params,
help = "PERSONS.PASSWORD_HELP_EDIT",
)
InputField(
label = "ACCOUNT.CONFIRMATION_LABEL",
secret = true,
maxLength = 72,
value = input["confirmation"] as String,
onChange = { update("confirmation", it) },
error = submit.errors["confirmation"],
)
InputField(
label = "MY_ACCOUNT.CURRENT_PASSWORD_LABEL",
secret = true,
maxLength = 72,
value = input["currentPassword"] as String,
onChange = { update("currentPassword", it) },
error = submit.errors["currentPassword"],
help = "MY_ACCOUNT.CURRENT_PASSWORD_HELP",
)
Spacer(Modifier.height(8.dp))
FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Button(onClick = { save() }, enabled = !submit.inProgress) { Text(t("PERSONS.SAVE")) }
OutlinedButton(onClick = onMyArea) { Text(t("MY_ACCOUNT.BACK")) }
}
}
}
}
// -------------------------------------------------------------------------
// 2. la eliminación: un formulario con un solo campo
// -------------------------------------------------------------------------
@Composable
private fun DeleteAccount() {
val d = LocalDependencies.current
val submit = remember { FormSubmit(d.messages) }
val confirmation = rememberConfirmation(d.messages)
val scope = rememberCoroutineScope()
var currentPassword by remember { mutableStateOf("") }
fun delete() {
scope.launch {
if (!confirmation.confirm("MY_ACCOUNT.DELETE_CONFIRM")) return@launch
val succeeded = submit.send { d.api.deleteMyAccount(currentPassword) }
if (succeeded) {
// primero el mensaje: se mostrará en la pantalla de inicio de sesión,
// adonde la navegación nos lleva apenas la sesión queda vacía
d.messages.flash("MY_ACCOUNT.DELETED")
d.session.forget(voluntary = true) // el servidor ha borrado la cookie del token
}
}
}
OutlinedCard(Modifier.fillMaxWidth(), border = BorderStroke(1.dp, Color(0xFFEF9A9A))) {
Column(Modifier.padding(16.dp)) {
Text(t("MY_ACCOUNT.DELETE_TITLE"), style = MaterialTheme.typography.titleLarge, color = Color(0xFFC62828))
Text(t("MY_ACCOUNT.DELETE_HELP"), color = Color.Gray)
InputField(
label = "MY_ACCOUNT.CURRENT_PASSWORD_LABEL",
secret = true,
maxLength = 72,
value = currentPassword,
onChange = {
currentPassword = it
submit.clearError("currentPassword")
},
error = submit.errors["currentPassword"],
)
Button(
onClick = { delete() },
enabled = !submit.inProgress,
colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFC62828)),
) { Text(t("MY_ACCOUNT.DELETE_SUBMIT")) }
}
}
ConfirmDialog(confirmation)
}
|