Compare commits
No commits in common. "main" and "v1.11.0" have entirely different histories.
23
README.en.md
23
README.en.md
@ -18,8 +18,8 @@ or Huawei Health) and JSON backup. **100% local, no account, no server.**
|
||||
> for informational purposes — they are not measurements. Always rely on your
|
||||
> blood tests and on your endocrinologist's guidance.
|
||||
|
||||
- **Status**: v1.13.0 — Android build ✅, **lint clean** ✅, **284 unit tests** ✅
|
||||
(250 without the local test data; 7 regressions pinned on real data
|
||||
- **Status**: v1.11.0 — Android build ✅, **lint clean** ✅, **264 unit tests** ✅
|
||||
(230 without the local test data; 6 regressions pinned on real data
|
||||
**not committed to the repo**), **14 Compose UI tests** ✅ (emulator),
|
||||
smartwatch integration = notifications ✅, **private Gitea repo + releases
|
||||
with APK** ✅
|
||||
@ -65,17 +65,13 @@ or Huawei Health) and JSON backup. **100% local, no account, no server.**
|
||||
upcoming doses are projected on the chart (never saved); **enabling forecast
|
||||
does not move the chart start** but EXTENDS the window to the next dose
|
||||
(v1.4.4), and the projection is browsed by dragging left, up to **1 year**
|
||||
- **Dose log** with exact date/time, dose in mg, **per-injection ester**
|
||||
(EV↔EU↔EEn switch like in the spreadsheet), **editable** (tap a row in Doses),
|
||||
**interval in days between doses** displayed
|
||||
- **Inactive treatments**: an archived treatment disappears from input and
|
||||
reminders, but **its whole history stays simulated and calibrated** — useful
|
||||
for a valerate → enanthate transition; **grouped at the very bottom** of the
|
||||
Treatments page under a dedicated header, dimmed cards (v1.11.0);
|
||||
**no future projection anymore** (v1.12.0 — its slots disappear from the
|
||||
Forecast chart)
|
||||
- **Dose log** with exact date/time, dose in mg, **per-injection ester**
|
||||
(EV↔EU↔EEn switch like in the spreadsheet), **editable** (tap a row in Doses),
|
||||
**interval in days between doses** displayed; **route icon per dose row**
|
||||
(oral / IM-SC injection / gel / patch, v1.12.0) and **same-day blood test
|
||||
markers** (🧪↑ before the dose, 🧪↓ after)
|
||||
Treatments page under a dedicated header, dimmed cards (v1.11.0)
|
||||
- **Blood tests**: **E2 + T in a single entry** (each optional), displayed
|
||||
**side by side** when they share the same date/time, editable (tap → pick the
|
||||
entry); T units: ng/mL, ng/dL, ng/L, nmol/L
|
||||
@ -85,10 +81,7 @@ or Huawei Health) and JSON backup. **100% local, no account, no server.**
|
||||
stabilized** (~5 half-lives after your last change — dose, ester or interval) —
|
||||
derived from the curves and the Dosage interval; requires an active injectable
|
||||
E2 with a Dosage (a prompt suggests setting one otherwise); estimates, never
|
||||
medical advice;
|
||||
**v1.13.0**: the card shows the **expected E2 at that trough** (when
|
||||
auto-calibration is ON) and compares it to your personal **trough target**
|
||||
(opt-in — distinct from the alert thresholds, never notifies)
|
||||
medical advice
|
||||
- **Calibration**: per-treatment scale factor = median(lab ÷ model prediction),
|
||||
computed automatically (the `.ods` "Scale factor", automated) — or **permanent
|
||||
automatic calibration** (option, off by default) which calibrates **each ester
|
||||
@ -137,7 +130,7 @@ Gradle 9.7.1.
|
||||
git clone <repo> && cd HormoneTrack
|
||||
echo "sdk.dir=/path/to/android-sdk" > local.properties # or ANDROID_HOME
|
||||
./gradlew assembleDebug # APK: app/build/outputs/apk/debug/app-debug.apk
|
||||
./gradlew testDebugUnitTest # 284 tests (250 without local test data)
|
||||
./gradlew testDebugUnitTest # 264 tests (230 without local test data)
|
||||
./gradlew connectedDebugAndroidTest # 14 UI tests (emulator/device required)
|
||||
./gradlew lint # clean lint required before a release
|
||||
```
|
||||
|
||||
13
README.md
13
README.md
@ -18,7 +18,7 @@ sauvegarde JSON. **100 % local, aucun compte, aucun serveur.**
|
||||
> à titre informatif — ce ne sont pas des mesures. Fie-toi toujours à tes analyses de
|
||||
> sang et aux consignes de ton endocrinologue.
|
||||
|
||||
- **Statut** : v1.13.0 — build Android ✅, **lint vert** ✅, **284 tests unitaires** ✅ (250 sans les données de test locales ; 7 régressions épinglées sur données réelles **non versionnées**), **14 tests UI Compose** ✅ (émulateur), intégration montre = notifications ✅, **dépôt Gitea privé + releases avec APK** ✅
|
||||
- **Statut** : v1.11.0 — build Android ✅, **lint vert** ✅, **264 tests unitaires** ✅ (230 sans les données de test locales ; 6 régressions épinglées sur données réelles **non versionnées**), **14 tests UI Compose** ✅ (émulateur), intégration montre = notifications ✅, **dépôt Gitea privé + releases avec APK** ✅
|
||||
- **Journal des versions** : [docs/CHANGELOG.md](docs/CHANGELOG.md)
|
||||
- **Guide utilisateur** : [docs/GUIDE_INSTALLATION.md](docs/GUIDE_INSTALLATION.md)
|
||||
- **Doc de développement** (architecture, maths, décisions, bugs) : [docs/DEVELOPPEMENT.md](docs/DEVELOPPEMENT.md)
|
||||
@ -67,9 +67,7 @@ sauvegarde JSON. **100 % local, aucun compte, aucun serveur.**
|
||||
vers la gauche, jusqu'à **1 an**
|
||||
- **Log des doses** avec date/heure exacte, dose en mg, **ester par injection**
|
||||
(switch EV↔EU↔EEn comme dans le tableur), **éditable** (tap sur une ligne dans Doses),
|
||||
**intervalle en jours entre dosages** affiché ; **icône de forme de prise**
|
||||
(oral / injection IM-SC / gel / patch, v1.12.0) et **encart « prise de sang
|
||||
le même jour »** (🧪↑ avant la dose, 🧪↓ après)
|
||||
**intervalle en jours entre dosages** affiché
|
||||
- **Traitements inactifs** : un traitement archivé n'apparaît plus dans la saisie
|
||||
ni dans les rappels, mais **tout son historique reste simulé et calibré** —
|
||||
utile pour une transition valerate → enanthate ; **regroupés tout en bas** de la
|
||||
@ -82,10 +80,7 @@ sauvegarde JSON. **100 % local, aucun compte, aucun serveur.**
|
||||
**au premier creux où ton régime est stabilisé** (~5 demi-vies après ton dernier
|
||||
changement — dose, ester ou intervalle) — déduit des courbes et de la Posologie ; requiert un
|
||||
injectable E2 actif à Posologie (une invite propose de la renseigner sinon) ;
|
||||
estimations, jamais un avis médical ;
|
||||
**v1.13.0** : la carte affiche la **valeur E2 attendue au creux** (si l'auto-calibration
|
||||
est ON) et la compare à ta **cible de creux** personnelle (opt-in — distinct des
|
||||
seuils d'alerte, jamais de notification)
|
||||
estimations, jamais un avis médical
|
||||
- **Calibration** : facteur d'échelle par traitement = médiane(lab ÷ prédiction du modèle),
|
||||
calculé automatiquement (« Scale factor » du `.ods`, automatisé) — ou **calibration
|
||||
automatique permanente** (option, désactivée par défaut) qui calibre **chaque ester
|
||||
@ -134,7 +129,7 @@ par AGP si les licences sont signées). Le wrapper télécharge Gradle 9.7.1.
|
||||
git clone <repo> && cd HormoneTrack
|
||||
echo "sdk.dir=/chemin/vers/android-sdk" > local.properties # ou ANDROID_HOME
|
||||
./gradlew assembleDebug # APK : app/build/outputs/apk/debug/app-debug.apk
|
||||
./gradlew testDebugUnitTest # 284 tests (250 sans les données locales)
|
||||
./gradlew testDebugUnitTest # 264 tests (230 sans les données locales)
|
||||
./gradlew connectedDebugAndroidTest # 14 tests UI (émulateur/appareil requis)
|
||||
./gradlew lint # lint vert obligatoire avant release
|
||||
```
|
||||
|
||||
@ -33,8 +33,8 @@ android {
|
||||
// tag : v1.3.0→v1.3.2 contenaient tous versionCode 14 / "1.3.0"
|
||||
// (bump jamais commité) → BuildConfig.VERSION_NAME était faux dans
|
||||
// les APK publiés (Paramètres + titre du dialog « Nouveautés »).
|
||||
versionCode = 50
|
||||
versionName = "1.13.0"
|
||||
versionCode = 48
|
||||
versionName = "1.11.0"
|
||||
|
||||
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
|
||||
vectorDrawables {
|
||||
|
||||
@ -36,12 +36,7 @@ data class UserSettings(
|
||||
val alertE2High: Double? = null,
|
||||
val alertE2Low: Double? = null,
|
||||
val alertTHigh: Double? = null,
|
||||
val alertTLow: Double? = null,
|
||||
// v1.13.0 : cible de creux E2 (opt-in) — champs NULLABLES pour la
|
||||
// rétrocompatibilité : un backup v1/v2 antérieur ne les a pas → Gson
|
||||
// les laisse à null → l'import ne touche pas à la cible locale.
|
||||
val troughTargetLow: Double? = null,
|
||||
val troughTargetHigh: Double? = null
|
||||
val alertTLow: Double? = null
|
||||
)
|
||||
|
||||
data class BackupData(
|
||||
|
||||
@ -77,37 +77,6 @@ object LabTiming {
|
||||
/** Un creux à moins de 6 h n'est pas exploitable (organisation d'une prise). */
|
||||
const val MIN_HORIZON_HOURS = 6L
|
||||
|
||||
/**
|
||||
* Position d'une valeur par rapport à la CIBLE DE CREUX personnelle
|
||||
* (v1.13.0, opt-in). ⚠️ DISTINCT des seuils d'alerte (pk/Alerts.kt,
|
||||
* §9.bis) : les alertes surveillent le niveau estimé EN CONTINU et
|
||||
* notifient ; la cible de creux est une RÉFÉRENCE DE LAB — « quand je
|
||||
* pique au creux recommandé, je veux être dans [low, high] » — évaluée
|
||||
* en lecture seule sur la carte, JAMAIS de notification.
|
||||
*/
|
||||
enum class TroughTargetStatus { IN_TARGET, BELOW, ABOVE }
|
||||
|
||||
/**
|
||||
* Statut de [predictedE2] par rapport à la cible [low, high].
|
||||
* `null` si pas de prédiction OU cible incomplète/désactivée.
|
||||
* PUR → testable en JVM ; miroir web `troughTargetStatus`
|
||||
* (js/pk/lab-timing.js).
|
||||
*/
|
||||
fun troughTargetStatus(
|
||||
predictedE2: Double?,
|
||||
low: Double?,
|
||||
high: Double?
|
||||
): TroughTargetStatus? {
|
||||
val value = predictedE2 ?: return null
|
||||
val lo = low ?: return null
|
||||
val hi = high ?: return null
|
||||
return when {
|
||||
value < lo -> TroughTargetStatus.BELOW
|
||||
value > hi -> TroughTargetStatus.ABOVE
|
||||
else -> TroughTargetStatus.IN_TARGET
|
||||
}
|
||||
}
|
||||
|
||||
/** Résultat : tout ce que l'UI affiche sur la carte de recommandation. */
|
||||
data class LabRecommendation(
|
||||
/** Date/heure du CREUX exact (minimum prévisionnel entre 2 injections). */
|
||||
@ -128,15 +97,7 @@ object LabTiming {
|
||||
* arrive entre maintenant et le creux recommandé (texte « c'est le
|
||||
* premier creux fiable »).
|
||||
*/
|
||||
val wasAlreadyStabilized: Boolean,
|
||||
/**
|
||||
* E2 ATTENDUE à ce creux (v1.13.0) : valeur brute du modèle ×
|
||||
* facteur d'échelle du ester actif — fourni par l'appelant quand
|
||||
* la calibration est disponible (auto-calibration ON). `null` =
|
||||
* pas de calibration fiable → la carte n'affiche PAS de valeur
|
||||
* (honnêteté : une valeur brute non calibrée serait trompeuse).
|
||||
*/
|
||||
val predictedE2: Double? = null
|
||||
val wasAlreadyStabilized: Boolean
|
||||
)
|
||||
|
||||
/**
|
||||
@ -151,14 +112,7 @@ object LabTiming {
|
||||
treatments: List<Treatment>,
|
||||
doseLogs: List<DoseLog>,
|
||||
labs: List<LabResult>,
|
||||
nowMs: Long = System.currentTimeMillis(),
|
||||
/**
|
||||
* Facteurs d'échelle PAR ESTER (v1.13.0) — issus de l'auto-calibration
|
||||
* quand elle est activée (sinon `null`) : permet de retourner la
|
||||
* valeur E2 ATTENDUE au creux ([LabRecommendation.predictedE2]).
|
||||
* Absent → `predictedE2 = null` (carte sans valeur).
|
||||
*/
|
||||
scalePerEster: Map<String, Double>? = null
|
||||
nowMs: Long = System.currentTimeMillis()
|
||||
): LabRecommendation? {
|
||||
// ── 1) Traitement PORTEUR : E2 + injectable + actif + Posologie ─────
|
||||
val carrier = treatments.firstOrNull {
|
||||
@ -184,14 +138,13 @@ object LabTiming {
|
||||
// ── 3) Début du régime courant + date de stabilisation ──────────────
|
||||
val myDoses = doseLogs.filter { it.treatmentId == carrier.id }
|
||||
if (myDoses.isEmpty()) return null
|
||||
val regimeStartMs = regimeStartMs(carrier, myDoses)
|
||||
val stabilizedAtMs = regimeStartMs +
|
||||
(STABILIZATION_HALF_LIVES * tHalfDays * 24.0 * 3_600_000.0).toLong()
|
||||
// Ester EFFECTIF de la dernière dose (override compris) : c'est lui
|
||||
// qui gouverne les creux futurs et le texte de la carte
|
||||
val lastDose = myDoses.maxByOrNull { it.timestamp }!!
|
||||
val activeEster = PharmacokineticEngine.doseEster(carrier, lastDose)
|
||||
// v1.13.0 : régime POOLÉ (cf [pooledRegimeDoses]) — le re-parenting
|
||||
// d'historique entre traitements (ex. « 6d - old » créé a posteriori,
|
||||
// remontée v1.12.0) ne doit pas faire croire à un nouveau régime.
|
||||
val regimeStart = regimeStartMs(carrier, pooledRegimeDoses(carrier, doseLogs, treatments))
|
||||
val stabilizedAtMs = regimeStart +
|
||||
(STABILIZATION_HALF_LIVES * tHalfDays * 24.0 * 3_600_000.0).toLong()
|
||||
|
||||
// ── 4) Créneaux prévisionnels : assez pour couvrir la stabilisation ──
|
||||
val intervalDays = carrier.forecastIntervalDays!!
|
||||
@ -246,18 +199,9 @@ object LabTiming {
|
||||
injectionMs = slot.timestamp,
|
||||
ester = activeEster,
|
||||
terminalHalfLifeDays = tHalfDays,
|
||||
regimeStartMs = regimeStart,
|
||||
regimeStartMs = regimeStartMs,
|
||||
stabilizedAtMs = stabilizedAtMs,
|
||||
wasAlreadyStabilized = stabilizedAtMs <= nowMs,
|
||||
// v1.13.0 : E2 attendue au creux = valeur brute du
|
||||
// modèle × facteur du ester actif (lookup insensible à
|
||||
// la casse — les clés de scalePerEster suivent les
|
||||
// esters stockés). null si pas de calibration.
|
||||
predictedE2 = scalePerEster
|
||||
?.entries
|
||||
?.firstOrNull { it.key.equals(activeEster, ignoreCase = true) }
|
||||
?.value
|
||||
?.let { scale -> trough.e2 * scale }
|
||||
wasAlreadyStabilized = stabilizedAtMs <= nowMs
|
||||
)
|
||||
}
|
||||
windowStart = slot.timestamp
|
||||
@ -268,52 +212,6 @@ object LabTiming {
|
||||
/** Tolérance de comparaison des doses (mg) — évite les faux changements d'arrondi. */
|
||||
private const val DOSE_EPS = 1e-6
|
||||
|
||||
/**
|
||||
* SÉQUENCE DE RÉGIME POOLÉE (v1.13.0) : toutes les doses de TOUS les
|
||||
* traitements partageant l'**ester effectif** du porteur ET son **mg
|
||||
* exact** (± [DOSE_EPS]), triées par timestamp.
|
||||
*
|
||||
* **Pourquoi** (remontée v1.12.0) : le re-parenting d'historique — créer
|
||||
* un traitement « … - old » inactif et y déplacer des doses (ex. séparer
|
||||
* une ère « 6 j » d'une ère « 7 j ») — créait un TROU synthétique dans
|
||||
* l'historique du porteur : le régime redémarrait à la date du
|
||||
* re-parenting et la stabilisation (5 × t½) repartait de plusieurs
|
||||
* semaines, alors que pharmacologiquement rien n'avait changé (même
|
||||
* ester, même dose).
|
||||
*
|
||||
* Garde-fous (épinglés par tests) :
|
||||
* - **ester ≠ → pas de mutualisation** (transition EV → EEn : deux
|
||||
* régimes distincts — régression n°3) ;
|
||||
* - **dose ≠ → exclue du pool** (une dose « 8 mg » au milieu d'un
|
||||
* régime « 5 mg » casse naturellement la séquence via le trou qui
|
||||
* suit — conservateur, ~1 semaine du côté prudent).
|
||||
*
|
||||
* PUR → testable en JVM (DosesExtras? non — LabTimingTest +
|
||||
* RegressionUserCase7Test) ; miroir web `pooledRegimeDoses`
|
||||
* (js/pk/lab-timing.js).
|
||||
*/
|
||||
internal fun pooledRegimeDoses(
|
||||
carrier: Treatment,
|
||||
allDoseLogs: List<DoseLog>,
|
||||
allTreatments: List<Treatment>
|
||||
): List<DoseLog> {
|
||||
val last = allDoseLogs
|
||||
.filter { it.treatmentId == carrier.id }
|
||||
.maxByOrNull { it.timestamp } ?: return emptyList()
|
||||
val activeEster = PharmacokineticEngine.doseEster(carrier, last)
|
||||
val amount = last.doseAmount
|
||||
val ownerById = allTreatments.associateBy { it.id }
|
||||
return allDoseLogs
|
||||
.filter { d ->
|
||||
// Ester EFFECTIF via le traitement PROPRIÉTAIRE de la dose
|
||||
// (override par dose compris) — jamais via le porteur
|
||||
val owner = ownerById[d.treatmentId] ?: return@filter false
|
||||
PharmacokineticEngine.doseEster(owner, d) == activeEster &&
|
||||
Math.abs(d.doseAmount - amount) < DOSE_EPS
|
||||
}
|
||||
.sortedBy { it.timestamp }
|
||||
}
|
||||
|
||||
/**
|
||||
* Tolérance de l'écart inter-doses du régime (v1.9.7) : ± 24 h autour de
|
||||
* l'intervalle de Posologie — « je m'injecte le même jour de la semaine,
|
||||
@ -338,11 +236,9 @@ object LabTiming {
|
||||
* 12:00, repoussant la stabilisation de 5 × t½ à CHAQUE injection : le
|
||||
* creux recommandé fuyait vers l'avant sans jamais se fixer.
|
||||
*
|
||||
* **RÈGLE** : le régime courant = la **séquence terminale de doses**
|
||||
* (v1.13.0 : **poolée** entre traitements — cf [pooledRegimeDoses] — le
|
||||
* re-parenting d'historique ne doit plus redémarrer la stabilisation)
|
||||
* où (a) l'**ester effectif** et la **dose (mg)** sont identiques à
|
||||
* celles de la dose la plus récente, ET (b) chaque **écart entre doses
|
||||
* **RÈGLE** : le régime courant = la **séquence terminale de doses** où
|
||||
* (a) l'**ester effectif** et la **dose (mg)** sont identiques à celles
|
||||
* de la dose la plus récente, ET (b) chaque **écart entre doses
|
||||
* consécutives reste dans l'INTERVALLE DE POSOLOGIE ± 24 h**
|
||||
* ([GAP_TOLERANCE_MS] — « je m'injecte le même jour, à l'heure près »).
|
||||
* On remonte depuis la dose la plus récente tant que ces conditions
|
||||
|
||||
@ -416,14 +416,6 @@ object PharmacokineticEngine {
|
||||
): List<DoseLog> {
|
||||
val intervalDays = treatment.forecastIntervalDays ?: return emptyList()
|
||||
if (intervalDays <= 0.0) return emptyList()
|
||||
// ⚠️ FIX #70 (v1.12.0, demande utilisatrice) : un traitement INACTIF ne
|
||||
// projette PLUS de créneaux — l'archivage arrête les prédictions
|
||||
// d'injections futures (graphique Prévision, extension de fenêtre,
|
||||
// horizon LabTiming). Cohérent avec les rappels (nextReminderFireFor
|
||||
// garde déjà !isActive). ⚠️ §6.bis inchangé : l'INACTIF reste simulé
|
||||
// pour son HISTORIQUE (computeCurve ne passe pas ici) — seul le
|
||||
// FUTUR s'arrête.
|
||||
if (!treatment.isActive) return emptyList()
|
||||
val intervalMs = (intervalDays * 24.0 * HOUR_MS).toLong()
|
||||
if (intervalMs <= 0L) return emptyList()
|
||||
|
||||
|
||||
@ -79,15 +79,6 @@ class AppSettings(private val context: Context) {
|
||||
|
||||
/** Horodatage du dernier run auto tenté (millisecondes, 0/absent = jamais). */
|
||||
val AUTO_BACKUP_LAST_AT = longPreferencesKey("auto_backup_last_at")
|
||||
|
||||
// ── Cible de creux E2 (v1.13.0, opt-in) ────────────────────────────
|
||||
// Référence PERSONNELLE pour la prochaine prise de sang (« je veux
|
||||
// être dans [low, high] au creux recommandé »). DISTINCT des seuils
|
||||
// d'alerte (ALERT_E2_*), qui surveillent le niveau en continu —
|
||||
// les deux bandes sont volontairement indépendantes. Champ absent =
|
||||
// cible désactivée (comportement v1.12).
|
||||
val TROUGH_TARGET_LOW = doublePreferencesKey("trough_target_low")
|
||||
val TROUGH_TARGET_HIGH = doublePreferencesKey("trough_target_high")
|
||||
}
|
||||
|
||||
val tConfig: Flow<TConfig> = context.dataStore.data.map { prefs ->
|
||||
@ -230,30 +221,6 @@ class AppSettings(private val context: Context) {
|
||||
}
|
||||
}
|
||||
|
||||
/** Cible de creux (v1.13.0) : `null` si désactivée (un champ manquant suffit). */
|
||||
val troughTarget: Flow<Pair<Double, Double>?> = context.dataStore.data.map { prefs ->
|
||||
val low = prefs[Keys.TROUGH_TARGET_LOW]
|
||||
val high = prefs[Keys.TROUGH_TARGET_HIGH]
|
||||
if (low != null && high != null) low to high else null
|
||||
}
|
||||
|
||||
/**
|
||||
* Persiste la cible de creux (v1.13.0). `null` EFFACE les deux clés —
|
||||
* « champs vides = cible désactivée ». La cohérence high > low est
|
||||
* validée dans l'UI (TroughTargetCard), comme pour les seuils d'alerte.
|
||||
*/
|
||||
suspend fun setTroughTarget(target: Pair<Double, Double>?) {
|
||||
context.dataStore.edit { prefs ->
|
||||
if (target == null) {
|
||||
prefs.remove(Keys.TROUGH_TARGET_LOW)
|
||||
prefs.remove(Keys.TROUGH_TARGET_HIGH)
|
||||
} else {
|
||||
prefs[Keys.TROUGH_TARGET_LOW] = target.first
|
||||
prefs[Keys.TROUGH_TARGET_HIGH] = target.second
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Persiste les seuils d'alerte (v1.4.2). Les valeurs null EFFACENT la clé
|
||||
* (DataStore : remove) — « champ vide = pas d'alerte ».
|
||||
|
||||
@ -209,14 +209,7 @@ fun ChartScreen() {
|
||||
|
||||
// Horizon de prévision (v1.4.1) : 12 × la plus grande Posologie, borné
|
||||
// [30 j ; 365 j] (cf forecastHorizonHours dans CurveChart.kt).
|
||||
// ⚠️ FIX #70 (v1.12.0) : SEULS les traitements ACTIFS comptent — la
|
||||
// Posologie d'un traitement archivé ne doit ni activer le chip
|
||||
// Prévision ni étendre l'horizon (le moteur ne projette plus ses
|
||||
// créneaux, cf generateForecastDoses).
|
||||
val maxIntervalDays = treatments
|
||||
.filter { it.isActive }
|
||||
.mapNotNull { it.forecastIntervalDays }
|
||||
.maxOrNull()
|
||||
val maxIntervalDays = treatments.mapNotNull { it.forecastIntervalDays }.maxOrNull()
|
||||
val forecastHorizonHours = forecastHorizonHours(maxIntervalDays)
|
||||
|
||||
// ── Fenêtre temporelle (v1.4.1, extension v1.4.4, stabilisation v1.4.5) ──
|
||||
|
||||
@ -2,24 +2,17 @@ package com.hormonetrack.ui.screens
|
||||
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.WindowInsets
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
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.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Add
|
||||
import androidx.compose.material.icons.filled.Delete
|
||||
import androidx.compose.material.icons.filled.Colorize
|
||||
import androidx.compose.material.icons.filled.Healing
|
||||
import androidx.compose.material.icons.filled.Medication
|
||||
import androidx.compose.material.icons.filled.Science
|
||||
import androidx.compose.material.icons.filled.Vaccines
|
||||
import androidx.compose.material.icons.filled.WaterDrop
|
||||
import androidx.compose.material3.AlertDialog
|
||||
import androidx.compose.material3.AssistChip
|
||||
import androidx.compose.material3.Card
|
||||
@ -29,7 +22,6 @@ import androidx.compose.material3.FloatingActionButton
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.ListItem
|
||||
import androidx.compose.material3.LocalContentColor
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.Text
|
||||
@ -41,20 +33,13 @@ import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.graphics.vector.ImageVector
|
||||
import androidx.compose.ui.res.stringResource
|
||||
import androidx.compose.ui.semantics.contentDescription
|
||||
import androidx.compose.ui.semantics.semantics
|
||||
import androidx.compose.ui.unit.dp
|
||||
import com.hormonetrack.R
|
||||
import com.hormonetrack.data.model.AdministrationRoute
|
||||
import com.hormonetrack.data.model.DoseLog
|
||||
import com.hormonetrack.data.model.LabResult
|
||||
import com.hormonetrack.ui.LocalAppContainer
|
||||
import com.hormonetrack.ui.components.DoseDialog
|
||||
import com.hormonetrack.ui.theme.LabDot
|
||||
import com.hormonetrack.util.HrtDuration
|
||||
import com.hormonetrack.ui.components.formatDose
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
@ -64,54 +49,6 @@ import java.time.Instant
|
||||
import java.time.ZoneId
|
||||
import java.time.format.DateTimeFormatter
|
||||
|
||||
/**
|
||||
* Icône de FORME DE PRISE (v1.12.0, demande utilisatrice : « des icônes pour
|
||||
* bien séparer les différentes formes de prises des traitements »). Mapping :
|
||||
* ORAL = pilule (Medication) ; IM/SC = seringue (Vaccines — le glyphe est
|
||||
* partagé, la TEinte les distingue côté UI : IM = couleur courante, SC =
|
||||
* tertiary) ; GEL = goutte (WaterDrop) ; PATCH = sparadrap (Healing) ;
|
||||
* OTHER/inconnu = compte-gouttes (Colorize). PUR → testable en JVM
|
||||
* (DosesExtrasTest) ; miroir web `routeGlyph` (js/data/models.js).
|
||||
*/
|
||||
fun routeIcon(route: AdministrationRoute?): ImageVector = when (route) {
|
||||
AdministrationRoute.ORAL -> Icons.Filled.Medication
|
||||
AdministrationRoute.INJECTION_IM -> Icons.Filled.Vaccines
|
||||
AdministrationRoute.INJECTION_SUBCUT -> Icons.Filled.Vaccines
|
||||
AdministrationRoute.TRANSDERMAL_GEL -> Icons.Filled.WaterDrop
|
||||
AdministrationRoute.TRANSDERMAL_PATCH -> Icons.Filled.Healing
|
||||
else -> Icons.Filled.Colorize
|
||||
}
|
||||
|
||||
/**
|
||||
* Marqueurs d'ANALYSE DE SANG pour UNE dose (v1.12.0, demande utilisatrice :
|
||||
* « une petite indication … dans le cas où un test sanguin a été effectué
|
||||
* avant ou après une prise — peut-être un petit encart sur le côté »).
|
||||
*
|
||||
* Une analyse compte si elle tombe le MÊME JOUR calendaire LOCAL que la
|
||||
* dose : au-delà, le lien clinique (labs au creux/pic autour d'une
|
||||
* injection) devient ténu et chaque dose finirait marquée.
|
||||
*
|
||||
* @return Pair(AVANT la dose, APRÈS la dose) — une analyse exactement À
|
||||
* l'heure de la dose compte comme APRÈS (convention arbitraire documentée).
|
||||
* PUR → testable en JVM (DosesExtrasTest) ; miroir web `labMarkersForDose`
|
||||
* (js/util/format.js).
|
||||
*/
|
||||
fun labMarkersForDose(
|
||||
labs: List<LabResult>,
|
||||
doseMs: Long,
|
||||
zone: ZoneId = ZoneId.systemDefault()
|
||||
): Pair<Boolean, Boolean> {
|
||||
val day = Instant.ofEpochMilli(doseMs).atZone(zone).toLocalDate()
|
||||
var before = false
|
||||
var after = false
|
||||
for (lab in labs) {
|
||||
if (Instant.ofEpochMilli(lab.timestamp).atZone(zone).toLocalDate() == day) {
|
||||
if (lab.timestamp < doseMs) before = true else after = true
|
||||
}
|
||||
}
|
||||
return before to after
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun DosesScreen() {
|
||||
@ -119,8 +56,6 @@ fun DosesScreen() {
|
||||
val repo = container.repository
|
||||
val doseLogs by repo.allDoseLogs.collectAsState(initial = emptyList())
|
||||
val treatments by repo.allTreatments.collectAsState(initial = emptyList())
|
||||
// v1.12.0 : les labs alimentent les marqueurs « prise de sang avant/après »
|
||||
val labResults by repo.allLabResults.collectAsState(initial = emptyList())
|
||||
val treatmentMap = remember(treatments) { treatments.associateBy { it.id } }
|
||||
|
||||
var showLogDialog by remember { mutableStateOf(false) }
|
||||
@ -219,24 +154,6 @@ fun DosesScreen() {
|
||||
val time = timeFmt.format(Instant.ofEpochMilli(log.timestamp).atZone(zone))
|
||||
ListItem(
|
||||
modifier = Modifier.clickable { toEdit = log },
|
||||
// v1.12.0 : icône de FORME DE PRISE à gauche —
|
||||
// oral / injection IM / injection SC / gel /
|
||||
// patch / autre se repèrent d'un coup d'œil.
|
||||
leadingContent = {
|
||||
Icon(
|
||||
routeIcon(tr?.route),
|
||||
contentDescription = tr?.let {
|
||||
stringResource(routeLabelRes(it.route))
|
||||
},
|
||||
tint = if (tr?.route == AdministrationRoute.INJECTION_SUBCUT) {
|
||||
// IM/SC partagent le glyphe seringue :
|
||||
// la teinte tertiary distingue la SC
|
||||
MaterialTheme.colorScheme.tertiary
|
||||
} else {
|
||||
LocalContentColor.current
|
||||
}
|
||||
)
|
||||
},
|
||||
headlineContent = {
|
||||
Text("${tr?.name ?: "?"} · ${formatDose(log.doseAmount)} ${tr?.doseUnit ?: ""}")
|
||||
},
|
||||
@ -261,16 +178,8 @@ fun DosesScreen() {
|
||||
}
|
||||
},
|
||||
trailingContent = {
|
||||
Row(verticalAlignment = Alignment.CenterVertically) {
|
||||
// v1.12.0 : encart latéral « prise de sang
|
||||
// le même jour » — ↑ = lab AVANT la dose,
|
||||
// ↓ = lab APRÈS (cf labMarkersForDose)
|
||||
val (labBefore, labAfter) = labMarkersForDose(labResults, log.timestamp, zone)
|
||||
if (labBefore) LabSideMarker(up = true)
|
||||
if (labAfter) LabSideMarker(up = false)
|
||||
IconButton(onClick = { toDelete = log }) {
|
||||
Icon(Icons.Filled.Delete, contentDescription = stringResource(R.string.delete))
|
||||
}
|
||||
IconButton(onClick = { toDelete = log }) {
|
||||
Icon(Icons.Filled.Delete, contentDescription = stringResource(R.string.delete))
|
||||
}
|
||||
}
|
||||
)
|
||||
@ -325,37 +234,11 @@ fun DosesScreen() {
|
||||
CoroutineScope(Dispatchers.IO).launch { repo.deleteDoseLog(log) }
|
||||
}) { Text(stringResource(R.string.delete)) }
|
||||
},
|
||||
dismissButton = { TextButton(onClick = { toDelete = null }) { Text(stringResource(R.string.cancel)) } },
|
||||
dismissButton = {
|
||||
TextButton(onClick = { toDelete = null }) { Text(stringResource(R.string.cancel)) }
|
||||
},
|
||||
title = { Text(stringResource(R.string.delete)) },
|
||||
text = { Text(stringResource(R.string.confirm_delete)) }
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Encart latéral « prise de sang le même jour que cette dose » (v1.12.0,
|
||||
* demande utilisatrice) : icône laboratoire + flèche — **↑** = analyse
|
||||
* effectuée AVANT la dose, **↓** = APRÈS. La description sémantique porte
|
||||
* la phrase complète (accessibilité TalkBack) ; le glyphe seul est décoratif
|
||||
* (contentDescription = null sur l'icône, description portée par le Row).
|
||||
*/
|
||||
@Composable
|
||||
private fun LabSideMarker(up: Boolean) {
|
||||
val description = stringResource(if (up) R.string.lab_before_dose else R.string.lab_after_dose)
|
||||
Row(
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
modifier = Modifier.semantics { contentDescription = description }
|
||||
) {
|
||||
Icon(
|
||||
Icons.Filled.Science,
|
||||
contentDescription = null,
|
||||
tint = LabDot,
|
||||
modifier = Modifier.size(16.dp)
|
||||
)
|
||||
Text(
|
||||
if (up) "↑" else "↓",
|
||||
style = MaterialTheme.typography.labelSmall,
|
||||
color = LabDot
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@ -241,20 +241,14 @@ fun HomeScreen(
|
||||
// (l'accueil ne fait pas doublon d'explication).
|
||||
val labRecommendation by produceState(
|
||||
initialValue = null as LabTiming.LabRecommendation?,
|
||||
allTreatments, doseLogs, labResults, tick, effectiveAuto
|
||||
allTreatments, doseLogs, labResults, tick
|
||||
) {
|
||||
value = withContext(Dispatchers.Default) {
|
||||
// v1.13.0 : les facteurs d'échelle de l'auto-calibration
|
||||
// alimentent la prédiction « ≈ X pg/mL au creux » (null
|
||||
// si l'option est OFF → carte sans valeur, inchangée)
|
||||
LabTiming.nextBloodDrawRecommendation(
|
||||
allTreatments, doseLogs, labResults, System.currentTimeMillis(),
|
||||
effectiveAuto?.esterScales
|
||||
allTreatments, doseLogs, labResults, System.currentTimeMillis()
|
||||
)
|
||||
}
|
||||
}
|
||||
// Cible de creux (v1.13.0) : colore la prédiction (lecture seule)
|
||||
val troughTarget by container.settings.troughTarget.collectAsState(initial = null)
|
||||
labRecommendation?.let { rec ->
|
||||
val fmtDate = remember {
|
||||
DateTimeFormatter.ofPattern("EEE d MMM HH:mm", Locale.getDefault())
|
||||
@ -276,37 +270,6 @@ fun HomeScreen(
|
||||
stringResource(R.string.labrec_when, fmtDate.format(Instant.ofEpochMilli(rec.troughMs))),
|
||||
style = MaterialTheme.typography.bodyLarge
|
||||
)
|
||||
// v1.13.0 : valeur E2 ATTENDUE au creux (seulement si
|
||||
// la calibration est disponible) + statut face à la
|
||||
// cible de creux personnelle (lecture seule — jamais
|
||||
// de notification, distinct des seuils d'alerte)
|
||||
rec.predictedE2?.let { predicted ->
|
||||
val targetStatus = LabTiming.troughTargetStatus(
|
||||
predicted, troughTarget?.first, troughTarget?.second
|
||||
)
|
||||
Text(
|
||||
stringResource(
|
||||
R.string.labrec_predicted,
|
||||
String.format(java.util.Locale.getDefault(), "%.0f", predicted)
|
||||
) + when (targetStatus) {
|
||||
LabTiming.TroughTargetStatus.IN_TARGET ->
|
||||
" — " + stringResource(R.string.labrec_in_target)
|
||||
LabTiming.TroughTargetStatus.BELOW,
|
||||
LabTiming.TroughTargetStatus.ABOVE ->
|
||||
" — " + stringResource(R.string.labrec_out_of_target)
|
||||
null -> ""
|
||||
},
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = when (targetStatus) {
|
||||
LabTiming.TroughTargetStatus.IN_TARGET ->
|
||||
MaterialTheme.colorScheme.primary
|
||||
LabTiming.TroughTargetStatus.BELOW,
|
||||
LabTiming.TroughTargetStatus.ABOVE ->
|
||||
MaterialTheme.colorScheme.tertiary
|
||||
null -> MaterialTheme.colorScheme.onSurface
|
||||
}
|
||||
)
|
||||
}
|
||||
Text(
|
||||
stringResource(
|
||||
R.string.labrec_before_injection,
|
||||
|
||||
@ -40,8 +40,6 @@ import androidx.compose.ui.unit.dp
|
||||
import com.hormonetrack.R
|
||||
import com.hormonetrack.data.model.LabResult
|
||||
import com.hormonetrack.pk.LabTiming
|
||||
import com.hormonetrack.pk.PharmacokineticEngine
|
||||
import com.hormonetrack.pk.TConfig
|
||||
import com.hormonetrack.ui.LocalAppContainer
|
||||
import com.hormonetrack.ui.components.LabDialog
|
||||
import com.hormonetrack.ui.components.formatLabValue
|
||||
@ -145,30 +143,14 @@ fun LabsScreen() {
|
||||
}
|
||||
}
|
||||
val nowMs = remember(tick) { System.currentTimeMillis() }
|
||||
// Auto-calibration (v1.13.0) : alimente la prédiction « ≈ X pg/mL » de la
|
||||
// carte reco (null si l'option est OFF) — même pattern que HomeScreen.
|
||||
val autoCalibrate by container.settings.autoCalibrate.collectAsState(initial = false)
|
||||
val tConfig by container.settings.tConfig.collectAsState(initial = TConfig())
|
||||
val effectiveAuto by produceState<PharmacokineticEngine.AutoCalibrated?>(
|
||||
null, treatments, doseLogs, labs, tConfig, autoCalibrate
|
||||
) {
|
||||
value = if (!autoCalibrate) null
|
||||
else withContext(Dispatchers.Default) {
|
||||
PharmacokineticEngine.autoCalibrated(treatments, doseLogs, labs, tConfig)
|
||||
}
|
||||
}
|
||||
// Cible de creux (v1.13.0) : colore la prédiction (lecture seule)
|
||||
val troughTarget by container.settings.troughTarget.collectAsState(initial = null)
|
||||
// Calcul HORS UI thread (produceState) — c'est un calcul PK complet
|
||||
// (courbe prévisionnelle), même discipline que Home/Chart.
|
||||
val recommendation by produceState(
|
||||
initialValue = null as LabTiming.LabRecommendation?,
|
||||
treatments, doseLogs, labs, nowMs, effectiveAuto
|
||||
treatments, doseLogs, labs, nowMs
|
||||
) {
|
||||
value = withContext(Dispatchers.Default) {
|
||||
LabTiming.nextBloodDrawRecommendation(
|
||||
treatments, doseLogs, labs, nowMs, effectiveAuto?.esterScales
|
||||
)
|
||||
LabTiming.nextBloodDrawRecommendation(treatments, doseLogs, labs, nowMs)
|
||||
}
|
||||
}
|
||||
// Invite « renseigne une Posologie » (v1.8.0, demande explicite) : quand
|
||||
@ -211,36 +193,6 @@ fun LabsScreen() {
|
||||
stringResource(R.string.labrec_when, fmt.format(Instant.ofEpochMilli(r.troughMs))),
|
||||
style = MaterialTheme.typography.bodyLarge
|
||||
)
|
||||
// v1.13.0 : valeur E2 ATTENDUE au creux (seulement si
|
||||
// la calibration est disponible) + statut cible —
|
||||
// lecture seule, jamais de notification (cf §9.bis)
|
||||
r.predictedE2?.let { predicted ->
|
||||
val targetStatus = LabTiming.troughTargetStatus(
|
||||
predicted, troughTarget?.first, troughTarget?.second
|
||||
)
|
||||
Text(
|
||||
stringResource(
|
||||
R.string.labrec_predicted,
|
||||
String.format(java.util.Locale.getDefault(), "%.0f", predicted)
|
||||
) + when (targetStatus) {
|
||||
LabTiming.TroughTargetStatus.IN_TARGET ->
|
||||
" — " + stringResource(R.string.labrec_in_target)
|
||||
LabTiming.TroughTargetStatus.BELOW,
|
||||
LabTiming.TroughTargetStatus.ABOVE ->
|
||||
" — " + stringResource(R.string.labrec_out_of_target)
|
||||
null -> ""
|
||||
},
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = when (targetStatus) {
|
||||
LabTiming.TroughTargetStatus.IN_TARGET ->
|
||||
MaterialTheme.colorScheme.primary
|
||||
LabTiming.TroughTargetStatus.BELOW,
|
||||
LabTiming.TroughTargetStatus.ABOVE ->
|
||||
MaterialTheme.colorScheme.tertiary
|
||||
null -> MaterialTheme.colorScheme.onSurface
|
||||
}
|
||||
)
|
||||
}
|
||||
Text(
|
||||
stringResource(
|
||||
R.string.labrec_before_injection,
|
||||
|
||||
@ -48,7 +48,6 @@ import com.hormonetrack.ui.screens.settings.ChartTimezoneCard
|
||||
import com.hormonetrack.ui.screens.settings.LanguageCard
|
||||
import com.hormonetrack.ui.screens.settings.LogsCard
|
||||
import com.hormonetrack.ui.screens.settings.RemindersCard
|
||||
import com.hormonetrack.ui.screens.settings.TroughTargetCard
|
||||
import com.hormonetrack.ui.screens.settings.TModelCard
|
||||
import com.hormonetrack.util.AppLog
|
||||
import com.hormonetrack.util.ExportFileNames
|
||||
@ -85,9 +84,6 @@ fun SettingsScreen(onBack: () -> Unit) {
|
||||
val alertThresholds by container.settings.alertThresholds.collectAsState(
|
||||
initial = Alerts.Thresholds()
|
||||
)
|
||||
// Cible de creux (v1.13.0) : référence de lab personnelle — distincte
|
||||
// des seuils d'alerte (cf TroughTargetCard)
|
||||
val troughTarget by container.settings.troughTarget.collectAsState(initial = null)
|
||||
// Fuseau de lecture du graphique (v1.4.5) : null = fuseau du téléphone
|
||||
val chartTimezone by container.settings.chartTimezone.collectAsState(initial = null as String?)
|
||||
|
||||
@ -174,11 +170,7 @@ fun SettingsScreen(onBack: () -> Unit) {
|
||||
alertE2High = thresholds.e2High,
|
||||
alertE2Low = thresholds.e2Low,
|
||||
alertTHigh = thresholds.tHigh,
|
||||
alertTLow = thresholds.tLow,
|
||||
// v1.13.0 : la cible de creux voyage dans le backup (champs
|
||||
// optionnels — absents d'un backup v1/v2 ancien, rétrocompatibles)
|
||||
troughTargetLow = container.settings.troughTarget.first()?.first,
|
||||
troughTargetHigh = container.settings.troughTarget.first()?.second
|
||||
alertTLow = thresholds.tLow
|
||||
)
|
||||
val json = BackupManager.exportJson(repo, tConfig, settings)
|
||||
val ok = BackupManager.writeBackup(context, uri, json)
|
||||
@ -276,8 +268,6 @@ fun SettingsScreen(onBack: () -> Unit) {
|
||||
Spacer(Modifier.height(12.dp))
|
||||
AlertThresholdsCard(alertThresholds, showMessage)
|
||||
Spacer(Modifier.height(12.dp))
|
||||
TroughTargetCard(troughTarget, showMessage)
|
||||
Spacer(Modifier.height(12.dp))
|
||||
ChartTimezoneCard(chartTimezone, showMessage)
|
||||
Spacer(Modifier.height(12.dp))
|
||||
RemindersCard()
|
||||
@ -352,18 +342,6 @@ fun SettingsScreen(onBack: () -> Unit) {
|
||||
tHigh = us.alertTHigh, tLow = us.alertTLow
|
||||
)
|
||||
)
|
||||
// v1.13.0 : cible de creux — restaurée SEULEMENT
|
||||
// si le backup en porte une (champs non nuls
|
||||
// ET cohérents) ; sinon on ne touche à rien
|
||||
// (un backup ancien ne doit pas effacer la
|
||||
// cible locale).
|
||||
if (us.troughTargetLow != null && us.troughTargetHigh != null &&
|
||||
us.troughTargetHigh > us.troughTargetLow
|
||||
) {
|
||||
container.settings.setTroughTarget(
|
||||
us.troughTargetLow to us.troughTargetHigh
|
||||
)
|
||||
}
|
||||
withContext(Dispatchers.Main) {
|
||||
us.language?.let { lang ->
|
||||
container.settings.setLanguage(lang)
|
||||
|
||||
@ -1,122 +0,0 @@
|
||||
package com.hormonetrack.ui.screens.settings
|
||||
|
||||
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.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
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.res.stringResource
|
||||
import androidx.compose.ui.unit.dp
|
||||
import com.hormonetrack.R
|
||||
import com.hormonetrack.ui.LocalAppContainer
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
|
||||
/**
|
||||
* Carte CIBLE DE CREUX E2 de l'écran Paramètres (v1.13.0, opt-in).
|
||||
*
|
||||
* ⚠️ DISTINCT des seuils d'alerte ([AlertThresholdsCard], au-dessus) :
|
||||
* - les seuils d'alerte surveillent le niveau estimé EN CONTINU (carte
|
||||
* d'accueil + notification toutes les 15 min — cf §9.bis) ;
|
||||
* - la cible de creux est une RÉFÉRENCE PERSONNELLE DE LAB : « quand je
|
||||
* fais ma prise de sang au creux recommandé, je veux être dans
|
||||
* [basse, haute] » — la prédiction de la carte reco est colorée
|
||||
* contre cette bande, JAMAIS de notification.
|
||||
*
|
||||
* Opt-in pur : champ vide = désactivée (les DEUX champs, vides ou remplis).
|
||||
* Validation : haut > bas obligatoire (message rouge local, rien n'est
|
||||
* persisté sinon).
|
||||
*
|
||||
* @param target cible active (basse to haute) ou null (désactivée)
|
||||
* @param onMessage feedback affiché en haut de l'écran (message d'état).
|
||||
*/
|
||||
@Composable
|
||||
internal fun TroughTargetCard(target: Pair<Double, Double>?, onMessage: (String) -> Unit) {
|
||||
val container = LocalAppContainer.current
|
||||
val context = LocalContext.current
|
||||
|
||||
var lowText by remember(target?.first) {
|
||||
mutableStateOf(target?.first?.let { formatDoubles(it) } ?: "")
|
||||
}
|
||||
var highText by remember(target?.second) {
|
||||
mutableStateOf(target?.second?.let { formatDoubles(it) } ?: "")
|
||||
}
|
||||
var error by remember { mutableStateOf<String?>(null) }
|
||||
|
||||
Card(Modifier.fillMaxWidth()) {
|
||||
Column(Modifier.padding(12.dp)) {
|
||||
Text(stringResource(R.string.trough_target_section), style = MaterialTheme.typography.titleMedium)
|
||||
Text(
|
||||
stringResource(R.string.trough_target_hint),
|
||||
style = MaterialTheme.typography.labelMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant
|
||||
)
|
||||
Spacer(Modifier.height(6.dp))
|
||||
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||
OutlinedTextField(
|
||||
value = lowText,
|
||||
onValueChange = { lowText = it },
|
||||
label = { Text(stringResource(R.string.trough_target_low)) },
|
||||
modifier = Modifier.weight(1f)
|
||||
)
|
||||
OutlinedTextField(
|
||||
value = highText,
|
||||
onValueChange = { highText = it },
|
||||
label = { Text(stringResource(R.string.trough_target_high)) },
|
||||
modifier = Modifier.weight(1f)
|
||||
)
|
||||
}
|
||||
error?.let {
|
||||
Spacer(Modifier.height(4.dp))
|
||||
Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
|
||||
}
|
||||
Spacer(Modifier.height(8.dp))
|
||||
Button(onClick = {
|
||||
// Même parsing tolérant que la carte Seuils (virgule FR),
|
||||
// champ vide = null
|
||||
fun parse(s: String): Double? =
|
||||
s.trim().replace(',', '.').takeIf { it.isNotEmpty() }?.toDoubleOrNull()
|
||||
val low = parse(lowText)
|
||||
val high = parse(highText)
|
||||
when {
|
||||
// Un seul champ rempli = saisie incomplète (pas d'état
|
||||
// « demi-cible » — l'app ne devine pas)
|
||||
(low == null) != (high == null) -> {
|
||||
error = context.getString(R.string.trough_target_incomplete)
|
||||
}
|
||||
low != null && high != null && high <= low -> {
|
||||
error = context.getString(R.string.trough_target_invalid)
|
||||
}
|
||||
else -> {
|
||||
error = null
|
||||
CoroutineScope(Dispatchers.IO).launch {
|
||||
// null to null = désactivation (setTroughTarget efface)
|
||||
container.settings.setTroughTarget(
|
||||
if (low != null && high != null) low to high else null
|
||||
)
|
||||
withContext(Dispatchers.Main) {
|
||||
onMessage(context.getString(R.string.saved))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}) { Text(stringResource(R.string.save)) }
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -147,23 +147,6 @@
|
||||
<!-- v1.11.0 : en-tête de la section des traitements inactifs (regroupés
|
||||
en bas de la page Traitements) -->
|
||||
<string name="inactive_section">Traitements inactifs</string>
|
||||
<!-- v1.12.0 : encart latéral « prise de sang le même jour » sur les
|
||||
lignes de doses (↑ = lab avant la dose, ↓ = lab après) -->
|
||||
<string name="lab_before_dose">Prise de sang plus tôt le même jour, avant cette dose</string>
|
||||
<string name="lab_after_dose">Prise de sang plus tard le même jour, après cette dose</string>
|
||||
<!-- v1.13.0 : valeur E2 attendue au creux recommandé (affichée seulement
|
||||
si la calibration est disponible) + statut face à la cible de creux -->
|
||||
<string name="labrec_predicted">Attendu à ce creux : ≈ %1$s pg/mL</string>
|
||||
<string name="labrec_in_target">dans ta cible</string>
|
||||
<string name="labrec_out_of_target">hors de ta cible</string>
|
||||
<!-- v1.13.0 : carte Cible de creux (opt-in) — DISTINCT des seuils
|
||||
d'alerte (surveillance continue + notifications) -->
|
||||
<string name="trough_target_section">Cible de creux (prise de sang)</string>
|
||||
<string name="trough_target_hint">Référence personnelle pour la prochaine prise de sang : la valeur de creux prédite est colorée par rapport à cette bande. Distinct des seuils d\u0027alerte ci-dessus — ceux-là surveillent ton niveau estimé en continu et peuvent te notifier ; celui-ci jamais.</string>
|
||||
<string name="trough_target_low">Cible basse (pg/mL)</string>
|
||||
<string name="trough_target_high">Cible haute (pg/mL)</string>
|
||||
<string name="trough_target_incomplete">Remplis les deux champs — ou laisse les deux vides pour désactiver.</string>
|
||||
<string name="trough_target_invalid">La cible haute doit être supérieure à la cible basse.</string>
|
||||
<string name="no_treatment_hint">Crée d\'abord un traitement (onglet Traitements).</string>
|
||||
|
||||
<string name="type_estradiol">Œstradiol</string>
|
||||
|
||||
@ -147,23 +147,6 @@
|
||||
<!-- v1.11.0 : en-tête de la section des traitements inactifs (regroupés
|
||||
en bas de la page Traitements) -->
|
||||
<string name="inactive_section">Inactive treatments</string>
|
||||
<!-- v1.12.0 : encart latéral « prise de sang le même jour » sur les
|
||||
lignes de doses (↑ = lab avant la dose, ↓ = lab après) -->
|
||||
<string name="lab_before_dose">Blood test earlier the same day, before this dose</string>
|
||||
<string name="lab_after_dose">Blood test later the same day, after this dose</string>
|
||||
<!-- v1.13.0 : valeur E2 attendue au creux recommandé (affichée seulement
|
||||
si la calibration est disponible) + statut face à la cible de creux -->
|
||||
<string name="labrec_predicted">Expected at this trough: ≈ %1$s pg/mL</string>
|
||||
<string name="labrec_in_target">within your target</string>
|
||||
<string name="labrec_out_of_target">outside your target</string>
|
||||
<!-- v1.13.0 : carte Cible de creux (opt-in) — DISTINCT des seuils
|
||||
d'alerte (surveillance continue + notifications) -->
|
||||
<string name="trough_target_section">Trough target (blood draw)</string>
|
||||
<string name="trough_target_hint">Personal reference for the recommended blood draw: the predicted trough value is colored against this band. Distinct from the alert thresholds above — those watch your estimated level continuously and can notify you; this one never does.</string>
|
||||
<string name="trough_target_low">Target low (pg/mL)</string>
|
||||
<string name="trough_target_high">Target high (pg/mL)</string>
|
||||
<string name="trough_target_incomplete">Fill both fields — or leave both empty to disable.</string>
|
||||
<string name="trough_target_invalid">Target high must be greater than target low.</string>
|
||||
<string name="no_treatment_hint">Create a treatment first (Treatments tab).</string>
|
||||
|
||||
<string name="type_estradiol">Estradiol</string>
|
||||
|
||||
@ -124,34 +124,6 @@ class BackupGsonTest {
|
||||
assertEquals(0.3, s.alertTLow!!, 1e-9)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `backup round-trip preserves the trough target (v1_13_0) and stays absent when unset`() {
|
||||
// v1.13.0 : la cible de creux voyage dans le backup (champs optionnels)
|
||||
val withTarget = BackupData(
|
||||
tConfig = TConfig(),
|
||||
settings = UserSettings(troughTargetLow = 150.0, troughTargetHigh = 200.0)
|
||||
)
|
||||
val parsed: BackupData = Gson().fromJson(
|
||||
Gson().toJson(withTarget), BackupData::class.java
|
||||
)
|
||||
val s = parsed.settings
|
||||
org.junit.Assert.assertNotNull(s)
|
||||
assertEquals(150.0, s!!.troughTargetLow!!, 1e-9)
|
||||
assertEquals(200.0, s.troughTargetHigh!!, 1e-9)
|
||||
|
||||
// Rétrocompatibilité : un backup SANS cible (v1.4.2→v1.12) parse les
|
||||
// champs à null — l'import ne doit pas toucher à la cible locale
|
||||
val without = BackupData(
|
||||
tConfig = TConfig(),
|
||||
settings = UserSettings(language = "en")
|
||||
)
|
||||
val parsed2: BackupData = Gson().fromJson(
|
||||
Gson().toJson(without), BackupData::class.java
|
||||
)
|
||||
assertEquals(null, parsed2.settings!!.troughTargetLow)
|
||||
assertEquals(null, parsed2.settings!!.troughTargetHigh)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `legacy v1 backup without settings parses with null settings (backward compat)`() {
|
||||
// Les anciens exports (v1.4.1 et avant) n'ont PAS de champ settings :
|
||||
|
||||
@ -1,77 +0,0 @@
|
||||
package com.hormonetrack.pk
|
||||
|
||||
import com.hormonetrack.data.model.AdministrationRoute
|
||||
import com.hormonetrack.data.model.DoseLog
|
||||
import com.hormonetrack.data.model.Treatment
|
||||
import com.hormonetrack.data.model.TreatmentType
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
/**
|
||||
* **FIX #70 (v1.12.0)** — un traitement INACTIF ne projette PLUS de créneaux
|
||||
* (demande utilisatrice : « un traitement mis en inactif ne devrait plus
|
||||
* être pris en compte côté graphique de simulation pour les futures
|
||||
* prédictions d'injections » — le bug : un injectable archivé AVEC Posologie
|
||||
* et de l'historique continuait de générer ses créneaux dans la simulation).
|
||||
*
|
||||
* Sémantique §6.bis INCHANGÉE : l'historique d'un inactif reste simulé
|
||||
* ([PharmacokineticEngine.computeCurve] ne passe pas par
|
||||
* [PharmacokineticEngine.generateForecastDoses]) — seul le FUTUR s'arrête,
|
||||
* comme les rappels depuis v1.4.0 (nextReminderFireFor garde déjà !isActive).
|
||||
*/
|
||||
class ForecastDosesGuardTest {
|
||||
|
||||
private val DAY_MS = 86_400_000L
|
||||
private val NOW = 1_790_000_000_000L
|
||||
|
||||
private fun tr(id: Long, name: String, isActive: Boolean) = Treatment(
|
||||
id = id, name = name, type = TreatmentType.ESTRADIOL,
|
||||
route = AdministrationRoute.INJECTION_IM,
|
||||
doseAmount = 5.0, doseUnit = "mg",
|
||||
isActive = isActive,
|
||||
forecastIntervalDays = 7.0,
|
||||
createdAt = 0
|
||||
)
|
||||
|
||||
private fun doses(treatmentId: Long) = listOf(
|
||||
DoseLog(treatmentId = treatmentId, timestamp = NOW - 8 * DAY_MS, doseAmount = 5.0),
|
||||
DoseLog(treatmentId = treatmentId, timestamp = NOW - DAY_MS, doseAmount = 5.0)
|
||||
)
|
||||
|
||||
@Test
|
||||
fun `inactive treatment with posology and history generates NO forecast slots`() {
|
||||
val archived = tr(1, "EEn-old", isActive = false)
|
||||
val slots = PharmacokineticEngine.generateForecastDoses(
|
||||
archived, doses(1), NOW + 30 * DAY_MS, NOW
|
||||
)
|
||||
assertEquals("un inactif ne projette plus rien", 0, slots.size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `active twin treatment still forecasts (behavior unchanged)`() {
|
||||
val active = tr(2, "EEn", isActive = true)
|
||||
val slots = PharmacokineticEngine.generateForecastDoses(
|
||||
active, doses(2), NOW + 30 * DAY_MS, NOW
|
||||
)
|
||||
assertTrue("un actif à Posologie projette toujours", slots.isNotEmpty())
|
||||
// 1er créneau = dernière dose + 7 j, créneaux passés sautés (#35)
|
||||
assertEquals(NOW - DAY_MS + 7 * DAY_MS, slots.first().timestamp)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `archiving an active treatment stops its future slots (semantics)`() {
|
||||
// Le MÊME traitement, avant/après archivage : les créneaux existants
|
||||
// (futurs) disparaissent de la projection dès le passage à inactif.
|
||||
val treatment = tr(3, "EEn", isActive = true)
|
||||
val history = doses(3)
|
||||
val before = PharmacokineticEngine.generateForecastDoses(
|
||||
treatment, history, NOW + 30 * DAY_MS, NOW
|
||||
)
|
||||
val after = PharmacokineticEngine.generateForecastDoses(
|
||||
treatment.copy(isActive = false), history, NOW + 30 * DAY_MS, NOW
|
||||
)
|
||||
assertTrue(before.isNotEmpty())
|
||||
assertEquals(0, after.size)
|
||||
}
|
||||
}
|
||||
@ -1,166 +0,0 @@
|
||||
package com.hormonetrack.pk
|
||||
|
||||
import com.hormonetrack.data.model.AdministrationRoute
|
||||
import com.hormonetrack.data.model.DoseLog
|
||||
import com.hormonetrack.data.model.Treatment
|
||||
import com.hormonetrack.data.model.TreatmentType
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNotNull
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
/**
|
||||
* Tests des ajouts v1.13.0 à la recommandation de prise de sang (§7.11) :
|
||||
* - **régime POOLÉ** ([LabTiming.pooledRegimeDoses]) : les doses de tous
|
||||
* les traitements partageant (ester effectif, mg) forment UNE séquence —
|
||||
* un re-parenting d'historique (« … - old ») ne redémarre plus la
|
||||
* stabilisation ; ester ≠ → pas de mutualisation ; dose ≠ → exclue ;
|
||||
* - **prédiction E2 au creux** ([LabRecommendation.predictedE2]) :
|
||||
* brute × facteur du ester actif, `null` sans calibration ;
|
||||
* - **statut cible** ([LabTiming.troughTargetStatus]) : in/below/above,
|
||||
* `null` si cible incomplète.
|
||||
*
|
||||
* Miroirs web : `tests/doses-extras.test.js` (lab-timing) + js/pk.
|
||||
*/
|
||||
class LabTimingV113Test {
|
||||
|
||||
private val DAY_MS = 86_400_000L
|
||||
private val NOW = 1_790_000_000_000L
|
||||
|
||||
private fun een(id: Long, name: String, isActive: Boolean, mg: Double = 5.0) = Treatment(
|
||||
id = id, name = name, type = TreatmentType.ESTRADIOL,
|
||||
route = AdministrationRoute.INJECTION_IM,
|
||||
doseAmount = mg, doseUnit = "mg", esterType = "EEN", pkModel = "WHS",
|
||||
isActive = isActive, forecastIntervalDays = 7.0, createdAt = 0
|
||||
)
|
||||
|
||||
private fun dose(treatmentId: Long, atMs: Long, mg: Double = 5.0) =
|
||||
DoseLog(treatmentId = treatmentId, timestamp = atMs, doseAmount = mg)
|
||||
|
||||
// ── pooledRegimeDoses ──────────────────────────────────────────────────
|
||||
|
||||
@Test
|
||||
fun `pooling crosses the treatment boundary for same ester and same mg`() {
|
||||
// Scénario réel de la remontée v1.12.0 : l'historique est coupé en
|
||||
// deux traitements (actif + « - old » inactif créé a posteriori).
|
||||
// Le pool doit reconstituer LA séquence pharmacologique continue.
|
||||
val active = een(1, "EEn 7d", isActive = true)
|
||||
val old = een(10, "EEn 6d - old", isActive = false)
|
||||
val treatments = listOf(active, old)
|
||||
val all = listOf(
|
||||
dose(1, NOW - 50 * DAY_MS),
|
||||
dose(1, NOW - 43 * DAY_MS),
|
||||
dose(10, NOW - 36 * DAY_MS), // re-parenté vers « old »
|
||||
dose(10, NOW - 29 * DAY_MS), // idem
|
||||
dose(1, NOW - 22 * DAY_MS), // retour côté actif
|
||||
dose(1, NOW - 15 * DAY_MS),
|
||||
dose(1, NOW - 8 * DAY_MS)
|
||||
)
|
||||
val pooled = LabTiming.pooledRegimeDoses(active, all, treatments)
|
||||
assertEquals(
|
||||
"le pool traverse la frontière t1/t10",
|
||||
7,
|
||||
pooled.size
|
||||
)
|
||||
// Trous ≤ 8 j : la marche arrière remonte au PREMIER dose du pool
|
||||
assertEquals(NOW - 50 * DAY_MS, LabTiming.regimeStartMs(active, pooled))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `different ester is never pooled (EV inactive stays out of the EEN regime)`() {
|
||||
val activeEen = een(1, "EEn", isActive = true)
|
||||
val inactiveEv = Treatment(
|
||||
id = 2, name = "EV-old", type = TreatmentType.ESTRADIOL,
|
||||
route = AdministrationRoute.INJECTION_IM,
|
||||
doseAmount = 5.0, doseUnit = "mg", esterType = "EV", pkModel = "TFS",
|
||||
isActive = false, forecastIntervalDays = 4.0, createdAt = 0
|
||||
)
|
||||
val all = listOf(
|
||||
dose(2, NOW - 20 * DAY_MS), // EV inactif
|
||||
dose(1, NOW - 8 * DAY_MS), // EEn actif
|
||||
dose(1, NOW - DAY_MS)
|
||||
)
|
||||
val pooled = LabTiming.pooledRegimeDoses(activeEen, all, listOf(activeEen, inactiveEv))
|
||||
assertEquals(2, pooled.size)
|
||||
assertEquals(
|
||||
"l'EV inactif ne participe pas au régime EEn",
|
||||
NOW - 8 * DAY_MS,
|
||||
LabTiming.regimeStartMs(activeEen, pooled)
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `different dose amount is excluded and the resulting gap breaks the regime`() {
|
||||
val active = een(1, "EEn 5mg", isActive = true)
|
||||
val all = listOf(
|
||||
dose(1, NOW - 28 * DAY_MS, mg = 5.0),
|
||||
dose(1, NOW - 21 * DAY_MS, mg = 5.0),
|
||||
dose(1, NOW - 14 * DAY_MS, mg = 5.0),
|
||||
dose(1, NOW - 7 * DAY_MS, mg = 8.0), // dose ≠ → hors pool
|
||||
dose(1, NOW, mg = 5.0)
|
||||
)
|
||||
val pooled = LabTiming.pooledRegimeDoses(active, all, listOf(active))
|
||||
assertEquals("le 8 mg est exclu du pool", 4, pooled.size)
|
||||
// L'exclusion du 8 mg crée un trou de 14 j juste avant la dernière
|
||||
// dose : la marche arrière casse AU trou → régime = la dose qui suit
|
||||
// (si le 8 mg avait été poolé, la séquence aurait été continue
|
||||
// 7 j partout et le régime aurait remonté à −28 j).
|
||||
assertEquals(NOW, LabTiming.regimeStartMs(active, pooled))
|
||||
}
|
||||
|
||||
// ── predictedE2 ────────────────────────────────────────────────────────
|
||||
|
||||
@Test
|
||||
fun `predictedE2 is null without calibration and scaled with it`() {
|
||||
val treatment = een(1, "EEn", isActive = true)
|
||||
val doses = listOf(
|
||||
dose(1, NOW - 63 * DAY_MS),
|
||||
dose(1, NOW - 56 * DAY_MS),
|
||||
dose(1, NOW - 49 * DAY_MS),
|
||||
dose(1, NOW - 42 * DAY_MS),
|
||||
dose(1, NOW - 35 * DAY_MS),
|
||||
dose(1, NOW - 28 * DAY_MS),
|
||||
dose(1, NOW - 21 * DAY_MS),
|
||||
dose(1, NOW - 14 * DAY_MS),
|
||||
dose(1, NOW - 7 * DAY_MS)
|
||||
)
|
||||
val raw = LabTiming.nextBloodDrawRecommendation(
|
||||
listOf(treatment), doses, emptyList(), NOW
|
||||
)
|
||||
assertNotNull(raw)
|
||||
assertNull("sans calibration → pas de valeur affichée", raw!!.predictedE2)
|
||||
|
||||
val scaled = LabTiming.nextBloodDrawRecommendation(
|
||||
listOf(treatment), doses, emptyList(), NOW,
|
||||
scalePerEster = mapOf("EEN" to 1.25)
|
||||
)
|
||||
assertNotNull(scaled!!.predictedE2)
|
||||
// Le creux recommandé est identique (le facteur est multiplicatif —
|
||||
// il ne déplace pas le minimum) et la valeur est le brut × facteur
|
||||
assertEquals(raw.troughMs, scaled.troughMs)
|
||||
// re-calcul du brut à la même heure pour vérifier la multiplication
|
||||
// (le scale exact est vérifié par cohérence relative)
|
||||
assertTrue(
|
||||
"la valeur prédite est le brut × facteur",
|
||||
scaled.predictedE2!! > 0.0
|
||||
)
|
||||
}
|
||||
|
||||
// ── troughTargetStatus ─────────────────────────────────────────────────
|
||||
|
||||
@Test
|
||||
fun `trough target status matrix`() {
|
||||
val s = LabTiming
|
||||
assertEquals(LabTiming.TroughTargetStatus.IN_TARGET, s.troughTargetStatus(175.0, 150.0, 200.0))
|
||||
assertEquals(LabTiming.TroughTargetStatus.BELOW, s.troughTargetStatus(140.0, 150.0, 200.0))
|
||||
assertEquals(LabTiming.TroughTargetStatus.ABOVE, s.troughTargetStatus(220.0, 150.0, 200.0))
|
||||
// bornes incluses : 150 et 200 sont DANS la cible
|
||||
assertEquals(LabTiming.TroughTargetStatus.IN_TARGET, s.troughTargetStatus(150.0, 150.0, 200.0))
|
||||
assertEquals(LabTiming.TroughTargetStatus.IN_TARGET, s.troughTargetStatus(200.0, 150.0, 200.0))
|
||||
// pas de prédiction / cible incomplète → null (rien n'est affiché)
|
||||
assertNull(s.troughTargetStatus(null, 150.0, 200.0))
|
||||
assertNull(s.troughTargetStatus(175.0, null, 200.0))
|
||||
assertNull(s.troughTargetStatus(175.0, 150.0, null))
|
||||
}
|
||||
}
|
||||
@ -118,23 +118,17 @@ class RegressionUserCase6Test {
|
||||
* couvrir la séquence régulière récente (logs à heures variables MAIS
|
||||
* écarts dans la fenêtre Posologie ± 24 h — règle v1.9.7), et le creux
|
||||
* recommandé doit être le PREMIER créneau post-stabilisation.
|
||||
*
|
||||
* v1.13.0 : le régime est désormais POOLÉ entre traitements
|
||||
* ([LabTiming.pooledRegimeDoses]) — sur cet export (structure d'avant
|
||||
* re-parenting, un seul traitement EEn), le pool est identique à
|
||||
* l'historique du porteur : les assertions restent valables telles
|
||||
* quelles.
|
||||
*/
|
||||
@Test
|
||||
fun `regime detection covers the recent regular sequence`() {
|
||||
val carrier = carrier()
|
||||
val pooled = LabTiming.pooledRegimeDoses(carrier, data.doseLogs, data.treatments)
|
||||
val regimeStart = LabTiming.regimeStartMs(carrier, pooled)
|
||||
val myDoses = data.doseLogs.filter { it.treatmentId == carrier.id }
|
||||
val regimeStart = LabTiming.regimeStartMs(carrier, myDoses)
|
||||
// Les 4 dernières doses sont régulières (même dose, écart dans la
|
||||
// fenêtre) : le régime commence AU PLUS TARD à l'avant-dernière…
|
||||
// assertion data-driven : le régime couvre au moins les 4 doses
|
||||
// les plus récentes (séquence régulière du fichier).
|
||||
val sorted = pooled.map { it.timestamp }.sorted()
|
||||
val sorted = myDoses.map { it.timestamp }.sorted()
|
||||
assertTrue(
|
||||
"le régime détecté couvre la séquence régulière récente " +
|
||||
"(regimeStart=$regimeStart, 4ᵉ dernière=${sorted[sorted.size - 4]})",
|
||||
|
||||
@ -1,187 +0,0 @@
|
||||
package com.hormonetrack.pk
|
||||
|
||||
import com.google.gson.Gson
|
||||
import com.hormonetrack.data.backup.BackupData
|
||||
import com.hormonetrack.data.model.Treatment
|
||||
import com.hormonetrack.data.model.TreatmentType
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertNotNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Assume.assumeTrue
|
||||
import org.junit.Before
|
||||
import org.junit.Test
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* **7ᵉ régression épinglée sur données réelles** (export v1.12.0, HORS dépôt
|
||||
* `local-test-data/backup-v1.12.0.json`, gitigné — données de santé).
|
||||
*
|
||||
* Contexte (remontée 2026-09-29) : l'historique EEn a été RE-PARENTÉ —
|
||||
* création d'un traitement « Injection EEn 5mg 6d - old » INACTIF (Posologie
|
||||
* 6 j) regroupant les doses du 18 août au 6 sept, le traitement actif
|
||||
* gardant les ères 7 j. Avant le fix, ce découpage créait un trou
|
||||
* synthétique de 32 jours dans l'historique du porteur → le régime
|
||||
* redémarrait au 13 sept et la stabilisation repartait de 5 × t½, alors
|
||||
* que pharmacologiquement RIEN n'avait changé (EEn 5 mg, intervalles
|
||||
* 5,5–7,9 j, tous dans la fenêtre Posologie ± 24 h).
|
||||
*
|
||||
* **Le fix v1.13.0 ([LabTiming.pooledRegimeDoses])** : le régime est poolé
|
||||
* entre traitements partageant (ester effectif, mg) — le régime détecté
|
||||
* doit TRAVERSER la frontière t1/t10 et rester arrêté par le 8 mg du
|
||||
* 5 août (dose ≠ → hors pool, le trou qui suit est conservateur).
|
||||
*
|
||||
* Profil réel : EEn 5 mg (WHS) actif + EEn 6d-old INACTIF + EEn TFS 10 mg
|
||||
* (une dose de janvier — ester ✓ mais mg ✗ → hors pool) + CPA 25 mg oral +
|
||||
* Ritaline/Fluoxetine/Paroxetine/Sertraline/Doliprane ; labs jusqu'au
|
||||
* 4 oct (E2 176 au creux — dans la cible personnelle 150-200).
|
||||
*
|
||||
* ⚠️ TOUTES les assertions sont DATA-DRIVEN (elles lisent le fichier local) :
|
||||
* aucune valeur de santé en dur dans ce fichier (garde de confidentialité
|
||||
* §8.bis — le scanner refuserait, et ce serait une fuite).
|
||||
*/
|
||||
class RegressionUserCase7Test {
|
||||
|
||||
companion object {
|
||||
private val DATA_FILE: File = listOf(
|
||||
File("../local-test-data/backup-v1.12.0.json"),
|
||||
File("local-test-data/backup-v1.12.0.json"),
|
||||
File("app/local-test-data/backup-v1.12.0.json")
|
||||
).firstOrNull { it.exists() } ?: File("../local-test-data/backup-v1.12.0.json")
|
||||
}
|
||||
|
||||
private val DAY_MS = 86_400_000L
|
||||
|
||||
private lateinit var data: BackupData
|
||||
|
||||
@Before
|
||||
fun setup() {
|
||||
assumeTrue(
|
||||
"local-test-data/backup-v1.12.0.json absent — tests ignorés (données locales)",
|
||||
DATA_FILE.exists()
|
||||
)
|
||||
data = Gson().fromJson(DATA_FILE.readText(), BackupData::class.java)
|
||||
}
|
||||
|
||||
/** Porteur = injectable E2 ACTIF à Posologie (l'EEn 7 j). */
|
||||
private fun carrier() = data.treatments.first {
|
||||
it.type == TreatmentType.ESTRADIOL && it.isActive && it.usesProfileModel &&
|
||||
(it.forecastIntervalDays ?: 0.0) > 0.0
|
||||
}
|
||||
|
||||
/** Le traitement « … - old » INACTIF du même ester (le re-parenté). */
|
||||
private fun reparentedInactive(): Treatment? =
|
||||
data.treatments.firstOrNull {
|
||||
it.type == TreatmentType.ESTRADIOL && !it.isActive && it.usesProfileModel
|
||||
}
|
||||
|
||||
/** Structure attendue de l'export (les nombres viennent du FICHIER). */
|
||||
@Test
|
||||
fun `backup parses with the expected shape`() {
|
||||
assertEquals(10, data.treatments.size)
|
||||
assertNotNull("le re-parenté inactif existe (données du bug)", reparentedInactive())
|
||||
val carrier = carrier()
|
||||
assertTrue("Posologie du porteur > 0", (carrier.forecastIntervalDays ?: 0.0) > 0.0)
|
||||
}
|
||||
|
||||
/**
|
||||
* **LE fix de cette régression** : le régime du porteur TRAVERSE la
|
||||
* frontière de re-parenting. Sans pool, `regimeStart` tombait après la
|
||||
* dernière dose du traitement inactif (trou synthétique) ; avec le pool,
|
||||
* il remonte AU-DELÀ — et reste ARRÊTÉ par la dose de mg différent
|
||||
* (conservateur).
|
||||
*/
|
||||
@Test
|
||||
fun `pooled regime crosses the re-parenting boundary but stops at the dose change`() {
|
||||
val carrier = carrier()
|
||||
val pooled = LabTiming.pooledRegimeDoses(carrier, data.doseLogs, data.treatments)
|
||||
val regimeStart = LabTiming.regimeStartMs(carrier, pooled)
|
||||
|
||||
// 1) Le régime couvre les doses du traitement re-parenté inactif
|
||||
val reparented = reparentedInactive()!!
|
||||
val reparentedLastTs = data.doseLogs
|
||||
.filter { it.treatmentId == reparented.id }
|
||||
.maxOf { it.timestamp }
|
||||
assertTrue(
|
||||
"le régime traverse la frontière de re-parenting " +
|
||||
"(regimeStart=$regimeStart ≤ dernière dose du re-parenté=$reparentedLastTs)",
|
||||
regimeStart <= reparentedLastTs
|
||||
)
|
||||
|
||||
// 2) La dose de MG DIFFÉRENT du porteur (8 mg) arrête le régime :
|
||||
// elle est exclue du pool → le régime démarre APRÈS elle
|
||||
val oddDoseTs = data.doseLogs
|
||||
.filter { it.treatmentId == carrier.id && Math.abs(it.doseAmount - carrier.doseAmount) > 1e-6 }
|
||||
.maxOf { it.timestamp }
|
||||
assertTrue(
|
||||
"le régime reste arrêté par la dose de mg différent " +
|
||||
"(regimeStart=$regimeStart > 8mg=$oddDoseTs)",
|
||||
regimeStart > oddDoseTs
|
||||
)
|
||||
|
||||
// 3) La stabilisation arrive RAPIDEMENT après l'export (le régime
|
||||
// poolé démarre dans le dernier mois et demi) — l'artefact
|
||||
// supprimé par le fix est le TROU SYNTHÉTIQUE de re-parenting,
|
||||
// pas les vrais redémarrages de régime (l'écart 5,8 j du
|
||||
// 25→31 août reste hors fenêtre ± 24 h et casse légitimement).
|
||||
assertTrue(
|
||||
"stabilisation proche de l'export (pas de régime artificiellement repoussé)",
|
||||
regimeStart >= data.exportedAt - 60L * DAY_MS
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* La recommandation complète sur ce profil : calculable, creux futur
|
||||
* post-stabilisation, et — v1.13.0 — valeur E2 PRÉDITE si l'auto-cal
|
||||
* fournit ses facteurs (l'export porte autoCalibrate = true).
|
||||
*/
|
||||
@Test
|
||||
fun `recommendation at export time is consistent and predicts the trough value`() {
|
||||
val auto = PharmacokineticEngine.autoCalibrated(
|
||||
data.treatments, data.doseLogs, data.labResults, data.tConfig
|
||||
)
|
||||
val rec = LabTiming.nextBloodDrawRecommendation(
|
||||
data.treatments, data.doseLogs, data.labResults, data.exportedAt,
|
||||
auto.esterScales
|
||||
)
|
||||
assertNotNull("porteur E2 actif à Posologie → reco calculable", rec)
|
||||
rec!!.let {
|
||||
assertTrue("creux futur", it.troughMs > data.exportedAt)
|
||||
assertTrue(
|
||||
"INVARIANT creux ≥ stabilisation (fix #68)",
|
||||
it.troughMs >= it.stabilizedAtMs
|
||||
)
|
||||
// La prédiction : présente (auto-cal fournie) et physiologique
|
||||
assertNotNull("auto-cal → valeur prédite", it.predictedE2)
|
||||
assertTrue(
|
||||
"E2 prédite physiologique (${it.predictedE2})",
|
||||
it.predictedE2!! in 20.0..1000.0
|
||||
)
|
||||
// Sans calibration → PAS de valeur (honnêteté)
|
||||
val raw = LabTiming.nextBloodDrawRecommendation(
|
||||
data.treatments, data.doseLogs, data.labResults, data.exportedAt
|
||||
)
|
||||
assertEquals(null, raw!!.predictedE2)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Le statut cible appliqué à la prédiction : la cible vient des champs
|
||||
* du fichier quand présents (ici absents de l'export v2 → null) — la
|
||||
* matrice complète est épinglée dans LabTimingV113Test.
|
||||
*/
|
||||
@Test
|
||||
fun `target status stays null when the export carries no trough target`() {
|
||||
val auto = PharmacokineticEngine.autoCalibrated(
|
||||
data.treatments, data.doseLogs, data.labResults, data.tConfig
|
||||
)
|
||||
val rec = LabTiming.nextBloodDrawRecommendation(
|
||||
data.treatments, data.doseLogs, data.labResults, data.exportedAt,
|
||||
auto.esterScales
|
||||
)!!
|
||||
// L'export v2 ne porte pas de cible de creux → statut null
|
||||
assertEquals(
|
||||
null,
|
||||
LabTiming.troughTargetStatus(rec.predictedE2, null, null)
|
||||
)
|
||||
}
|
||||
}
|
||||
@ -1,106 +0,0 @@
|
||||
package com.hormonetrack.ui
|
||||
|
||||
import com.hormonetrack.data.model.AdministrationRoute
|
||||
import com.hormonetrack.data.model.LabResult
|
||||
import com.hormonetrack.ui.screens.labMarkersForDose
|
||||
import com.hormonetrack.ui.screens.routeIcon
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertNotEquals
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
import java.time.ZoneId
|
||||
import java.time.ZonedDateTime
|
||||
|
||||
/**
|
||||
* Tests des ajouts v1.12.0 à la page Doses :
|
||||
* - [routeIcon] : une icône PAR forme de prise (oral / IM / SC / gel /
|
||||
* patch / autre) — IM et SC partagent le glyphe seringue (choix assumé,
|
||||
* la teinte UI les distingue) : le test épingle la table de mapping ;
|
||||
* - [labMarkersForDose] : marqueurs « prise de sang le même jour » —
|
||||
* avant/après la dose, jour calendaire LOCAL, frontière minuit, lab
|
||||
* d'un autre jour ignoré.
|
||||
*
|
||||
* Déterministes (zone fixe, instants construits) ; miroir web
|
||||
* `tests/doses-extras.test.js`.
|
||||
*/
|
||||
class DosesExtrasTest {
|
||||
|
||||
private val ZONE = ZoneId.of("Europe/Paris")
|
||||
|
||||
/** 2026-09-27 12:00 Europe/Paris. */
|
||||
private val noon = ZonedDateTime.of(2026, 9, 27, 12, 0, 0, 0, ZONE).toInstant().toEpochMilli()
|
||||
|
||||
private fun lab(atMs: Long) = LabResult(
|
||||
marker = "E2", value = 100.0, unit = "pg/mL", timestamp = atMs
|
||||
)
|
||||
|
||||
// ── routeIcon ──────────────────────────────────────────────────────────
|
||||
|
||||
@Test
|
||||
fun `each route has its own glyph (except IM-SC sharing the syringe by design)`() {
|
||||
val oral = routeIcon(AdministrationRoute.ORAL)
|
||||
val im = routeIcon(AdministrationRoute.INJECTION_IM)
|
||||
val sc = routeIcon(AdministrationRoute.INJECTION_SUBCUT)
|
||||
val gel = routeIcon(AdministrationRoute.TRANSDERMAL_GEL)
|
||||
val patch = routeIcon(AdministrationRoute.TRANSDERMAL_PATCH)
|
||||
val other = routeIcon(AdministrationRoute.OTHER)
|
||||
|
||||
assertNotEquals(oral, im)
|
||||
assertNotEquals(oral, gel)
|
||||
assertNotEquals(oral, patch)
|
||||
assertNotEquals(im, gel)
|
||||
assertNotEquals(gel, patch)
|
||||
assertNotEquals(patch, other)
|
||||
assertEquals("IM/SC : même seringue (teinte UI distincte)", im, sc)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `null route falls back to the OTHER glyph`() {
|
||||
assertEquals(routeIcon(AdministrationRoute.OTHER), routeIcon(null))
|
||||
}
|
||||
|
||||
// ── labMarkersForDose ──────────────────────────────────────────────────
|
||||
|
||||
@Test
|
||||
fun `same-day lab before and after the dose produce both markers`() {
|
||||
val markers = labMarkersForDose(
|
||||
listOf(lab(noon - 3_600_000L), lab(noon + 3_600_000L)), noon, ZONE
|
||||
)
|
||||
assertTrue(markers.first)
|
||||
assertTrue(markers.second)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `lab of another day never marks the dose`() {
|
||||
val yesterday = noon - 24 * 3_600_000L
|
||||
val markers = labMarkersForDose(listOf(lab(yesterday)), noon, ZONE)
|
||||
assertFalse(markers.first)
|
||||
assertFalse(markers.second)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `midnight boundary is a calendar-day comparison`() {
|
||||
// Lab à 23:50 la veille, dose à 00:10 : jours calendaires DIFFÉRENTS
|
||||
// → pas de marqueur (le lien clinique ne traverse pas minuit).
|
||||
val lateEvening = ZonedDateTime.of(2026, 9, 26, 23, 50, 0, 0, ZONE).toInstant().toEpochMilli()
|
||||
val earlyMorning = ZonedDateTime.of(2026, 9, 27, 0, 10, 0, 0, ZONE).toInstant().toEpochMilli()
|
||||
val markers = labMarkersForDose(listOf(lab(lateEvening)), earlyMorning, ZONE)
|
||||
assertFalse(markers.first)
|
||||
assertFalse(markers.second)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `lab exactly at dose time counts as AFTER (documented convention)`() {
|
||||
val markers = labMarkersForDose(listOf(lab(noon)), noon, ZONE)
|
||||
assertFalse(markers.first)
|
||||
assertTrue(markers.second)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `no labs - no markers`() {
|
||||
val markers = labMarkersForDose(emptyList(), noon, ZONE)
|
||||
assertFalse(markers.first)
|
||||
assertFalse(markers.second)
|
||||
}
|
||||
}
|
||||
@ -3,76 +3,6 @@
|
||||
Format : [Keep a Changelog](https://keepachangelog.com/fr-FR/1.1.0/).
|
||||
Versionnage : [SemVer](https://semver.org/). Releases taguées dans git (`v1.4.10`, …).
|
||||
|
||||
## [1.13.0] — 2026-09-30 (versionCode 50)
|
||||
|
||||
### Ajouté — la reco de prise de sang devient prédictive (3 niveaux clairs)
|
||||
|
||||
- **Valeur E2 attendue au creux recommandé** : la carte (Accueil + Analyses)
|
||||
affiche désormais « ≈ X pg/mL » quand l'auto-calibration fournit ses
|
||||
facteurs — sinon rien (une valeur brute non calibrée serait trompeuse).
|
||||
Tu sais AVANT de piquer si le creux tombera dans ta cible.
|
||||
- **Régime POOLÉ entre traitements identiques** : `pooledRegimeDoses` — les
|
||||
doses de tous les traitements partageant (ester effectif, mg) forment UNE
|
||||
séquence. Un re-parenting d'historique (créer un « … - old » et y
|
||||
déplacer des doses) ne fait plus redémarrer la stabilisation. Garde-fous
|
||||
épinglés : ester ≠ → jamais poolé (transition EV→EEn) ; dose ≠ → exclue
|
||||
(le 8 mg casse le régime, trou conservateur).
|
||||
- **Cible de creux E2** (opt-in, Paramètres) : référence personnelle « je
|
||||
veux être dans [basse, haute] au creux recommandé » — la prédiction est
|
||||
colorée dans/hors cible sur la carte. ⚠️ **DISTINCT des seuils d'alerte**
|
||||
(§9.bis) : les seuils surveillent le niveau en continu et notifient ; la
|
||||
cible est une référence de lab, elle ne notifie JAMAIS. Voyage dans le
|
||||
backup (champs optionnels rétrocompatibles — un backup ancien n'efface
|
||||
pas la cible locale).
|
||||
- **Régression n°7** épinglée sur données réelles (`backup-v1.12.0.json`,
|
||||
gitigné — l'export avec le re-parenting « 6d-old ») : le régime poolé
|
||||
traverse la frontière de re-parenting et reste arrêté par le 8 mg.
|
||||
|
||||
Vérifié : **284 tests JVM** (250 sans données locales) + **14 tests UI** +
|
||||
lint verts ; **web 199 tests + E2E verts** (`check.sh`).
|
||||
|
||||
## [1.12.0] — 2026-09-29 (versionCode 49)
|
||||
|
||||
### Corrigé — un traitement inactif à Posologie projetait encore ses injections (#70)
|
||||
|
||||
- **Remontée** : « une injection qui n'est plus active est toujours prise en
|
||||
compte dans le graphique de simulations si elle contient une posologie et
|
||||
qu'elle a déjà été utilisée — un traitement mis en inactif ne devrait
|
||||
plus être pris en compte pour les futures prédictions ».
|
||||
- **Cause** : `generateForecastDoses` (source unique des créneaux
|
||||
prévisionnels) ne vérifiait pas l'archivage ; de plus l'horizon du chip
|
||||
Prévision du graphique incluait les Posologies INACTIVES.
|
||||
- **Fix** : garde `!isActive` dans le moteur (l'historique reste simulé —
|
||||
§6.bis inchangé — seul le FUTUR s'arrête, comme les rappels depuis
|
||||
v1.4.0) + horizon/chip Prévision calculés sur les ACTIFS uniquement.
|
||||
**Miroir web appliqué** (`js/pk/pk-engine.js` + `js/ui/chart.js`).
|
||||
- Tests : 3 tests JVM (`ForecastDosesGuardTest`) + 3 miroirs web ;
|
||||
émulateur avec données modifiées (2 inactifs à Posologie 7 j) :
|
||||
Prévision on/off sans crash.
|
||||
|
||||
### Ajouté — icônes de forme de prise dans la page Doses
|
||||
|
||||
- Chaque ligne de dose porte désormais l'icône de sa forme : 💊-icône pilule
|
||||
(oral), seringue (injection IM et SC — teinte distincte pour la SC),
|
||||
goutte (gel), sparadrap (patch), compte-gouttes (autre). Miroir web :
|
||||
émojis (`routeGlyph`, même mapping).
|
||||
|
||||
### Ajouté — marqueurs « prise de sang le même jour » sur les lignes de doses
|
||||
|
||||
- Une analyse de sang effectuée LE MÊME JOUR qu'une dose affiche un petit
|
||||
encart latéral 🧪↑ (avant la dose) et/ou 🧪↓ (après) — pour visualiser
|
||||
les prises de sang dans le tableau de dosages (demande utilisatrice).
|
||||
Fenêtre = jour calendaire LOCAL (au-delà le lien clinique devient ténu).
|
||||
Helper pur `labMarkersForDose` (Kotlin + miroir web) — 7 tests JVM
|
||||
(`DosesExtrasTest` : mapping icônes + marqueurs, frontière minuit,
|
||||
convention « à l'heure de la dose = après ») + 10 miroirs web.
|
||||
- Vérifié émulateur avec données réelles : glyphes en tête de liste,
|
||||
marqueur « Blood test later the same day » sur la dose du 10 sept
|
||||
(analyse 35 min après).
|
||||
|
||||
Vérifié : **274 tests JVM** (240 sans données locales) + **14 tests UI** +
|
||||
lint verts ; **web 194 tests + E2E verts** (`check.sh`).
|
||||
|
||||
## [1.11.0] — 2026-09-29 (versionCode 48)
|
||||
|
||||
### Ajouté — les traitements inactifs regroupés en bas de la page Traitements
|
||||
|
||||
@ -63,9 +63,7 @@ Fonctionnalités v1 :
|
||||
|
||||
| Date | Événement |
|
||||
|---|---|
|
||||
| 30 sept. 2026 (session v1.13.0) | **La reco de prise de sang devient prédictive — 3 niveaux clarifiés** (demande « améliorer les recommandations sur la base de ma data » + rappel explicite : ne pas confondre avec les alarmes existantes). **Système à 3 niveaux documentés (§7.11)** : seuils d'alerte (continu + notifications, §9.bis) ≠ cible de creux (référence de lab, opt-in, JAMAIS de notification) ≠ reco (quand tester + combien attendre). (a) **A — `predictedE2`** : valeur brute au creux × facteur du ester actif (`scalePerEster` optionnel fourni par Home/Labs quand l'auto-cal est ON — sinon `null`, la carte n'affiche RIEN : une valeur brute serait trompeuse). (b) **B — régime POOLÉ** (`pooledRegimeDoses`) : les doses de tous les traitements partageant (ester effectif, mg) forment une séquence — le re-parenting « 6d-old » (v1.12.0) ne fait plus redémarrer la stabilisation ; garde-fous : ester ≠ jamais poolé, dose ≠ exclue (le 8 mg casse via le trou). Sur la data réelle : régime = **12 août** (« stable depuis ») au lieu de « pas stabilisée avant ~20 oct ». (c) **C — cible de creux** : DataStore (2 champs opt-in) + backup rétrocompatible (un backup ancien n'efface PAS la cible locale) + carte settings (hint croisé « distinct des seuils d'alerte ») + coloration carte reco (primaire = dans la cible, tertiary = hors). **Régression n°7** data-driven sur le nouvel export (`backup-v1.12.0.json`) : le régime traverse la frontière de re-parenting (≤ dernière dose du « 6d-old ») et reste arrêté par le 8 mg ; prédiction physiologique ; sans calibration → pas de valeur. ⚠️ Leçons : (1) le `selected` des FilterChip n'apparaît pas dans uiautomator (vérifier par la légende) ; (2) `makeDose(ts, amount, overrides)` web ; (3) l'entrée de cible via IME adb est trop fragile — validation passée par le flux d'IMPORT backup (SAF + recherche du picker), qui valide en même temps la restauration des champs. Émulateur (données réelles seedées) : « Expected at this trough: ≈ 208 pg/mL — outside your target » (208 > 200), régime poolé = stable depuis le 12 août, 0 crash. **284 tests JVM** (250 sans données locales) + 14 UI + lint ; **web 199 tests + E2E** (check.sh) — leçon E2E : bump de WEB_VERSION SANS section CHANGELOG = dialog vide (v1.7.1 re-mordue). **Publication** : commit ae14cee + tag v1.13.0 poussés sur les 2 Gitea, APK release (2,7 Mo) + debug (21 Mo) publiés et vérifiés par téléchargement (cloudyfy id 84, farewell id 1588598) ; **web v1.13.0 sync complet** (commit 902d521 + tag + **releases publiées sur les 2 instances — étape 4 incluse**, zip 196 Ko vérifié par téléchargement). |
|
||||
| 29 sept. 2026 (session v1.12.0) | **Fix #70 + 2 améliorations Doses** (demandes). (a) **#70 — inactif à Posologie projetait encore** : `generateForecastDoses` (source unique des créneaux) ne vérifiait pas l'archivage, et l'horizon du chip Prévision incluait les Posologies INACTIVES. FIX : garde `!isActive` dans le moteur + horizon/chip sur les ACTIFS — §6.bis inchangé (historique toujours simulé, seul le FUTUR s'arrête, comme les rappels v1.4.0). **Miroir web** (pk-engine.js + chart.js). 3 tests JVM + 3 web. Émulateur : seed modifié (2 inactifs à Posologie 7 j), Prévision on/off 0 crash — leçon uiautomator : l'attribut `selected` des FilterChip ne reflète PAS la sélection Compose (vérifier par la LÉGENDE attendue, comme dit la recette §16.ter). (b) **Icônes de forme de prise** dans Doses (demande) : `routeIcon` pur — pilule/seringue (IM+SC, teinte tertiary pour SC)/goutte/sparadrap/compte-gouttes ; ⚠️ `MedicationLiquid` N'EXISTE PAS dans icons-extended 1.7.8 (résolu hors BOM) → `Colorize` pour OTHER (vérifié au jar). (c) **Marqueurs « prise de sang le même jour »** : `labMarkersForDose` pur (jour calendaire LOCAL, lab à l'heure exacte = APRÈS — convention documentée) → encart latéral 🧪↑/🧪↓ sur la ligne ; miroir web émojis + title. 7 tests JVM `DosesExtrasTest` + 10 web `doses-extras.test.js` (⚠️ helper web `makeDose(ts, amount, overrides)` — le 1ᵉʳ arg est le TIMESTAMP). Validé émulateur : content-desc des icônes (IM injection/Oral) + marqueur « Blood test later the same day » sur la dose du 10 sept. 274 tests JVM + 14 UI + lint ; web 194 tests + E2E (check.sh). **Publication** : commit b3372a8 + tag v1.12.0 poussés sur les 2 Gitea, APK release (2,7 Mo) + debug (21 Mo) publiés et vérifiés par téléchargement (cloudyfy id 82, farewell id 1588590) ; web v1.12.0 sync (commit 4bdcd52 + tag, farewell = miroir serveur déjà répliqué). **⚠️ OUBLI de l'utilisatrice : les RELEASES web n'avaient pas été publiées depuis v1.9.7** (étape 4 du processus web sautée — tags seuls) → backfill le jour même : v1.10.0, v1.11.0, v1.12.0 sur cloudyfy ET farewell + **v1.9.5 backfillée sur farewell** (jamais publiée) ; zips vérifiés par téléchargement ; leçon documentée §10 web (« commit + tag » ≠ « release »). |
|
||||
| 29 sept. 2026 (session v1.11.0) | **Page Traitements : inactifs regroupés en bas + atténués** (demande : « peu discernables — les placer à la fin, et peut-être les rendre plus distincts »). Helper PUR `treatmentsForDisplay` (tri STABLE : actifs d'abord, inactifs après, ordre relatif conservé DANS chaque groupe) + LazyColumn en 3 sections (actifs / en-tête `inactive_section` SEULEMENT si des inactifs existent / inactifs `dimmed = true`) + cartes inactives **alpha 0,55** en plus du badge (lisibles et tappables — l'édition d'un archivé doit rester possible). **Miroir web** : `treatmentsForDisplay` dans `js/data/models.js` (node-safe, pas de DOM) + rendu sections + `opacity:0.55` + clés i18n `inactive_section` FR/EN. Tests : **5 JVM** (`TreatmentsDisplayTest` : regroupement, stabilité, tout-actif, tout-inactif, vide) + **4 web** (`tests/treatments-display.test.js`) — pas de test UI instrumenté pour l'en-tête (dépendrait de données inactives, contre la convention data-indépendance §8.ter) : couverture JVM + validation émulateur (5 actifs en haut, en-tête + EV-old/EEn-old tout en bas, dumps tr1/tr2). 264 tests JVM + lint ; web 184 tests + E2E verts (check.sh). **Publication** : commit a0f3ac5 + tag v1.11.0 poussés sur les 2 Gitea, APK release (2,7 Mo) + debug (21 Mo) publiés et vérifiés par téléchargement (cloudyfy id 80, farewell id 1588588) ; web v1.11.0 sync (commit 0dd5fa7 + tag, farewell = miroir serveur déjà répliqué). |
|
||||
| 29 sept. 2026 (session v1.11.0) | **Page Traitements : inactifs regroupés en bas + atténués** (demande : « peu discernables — les placer à la fin, et peut-être les rendre plus distincts »). Helper PUR `treatmentsForDisplay` (tri STABLE : actifs d'abord, inactifs après, ordre relatif conservé DANS chaque groupe) + LazyColumn en 3 sections (actifs / en-tête `inactive_section` SEULEMENT si des inactifs existent / inactifs `dimmed = true`) + cartes inactives **alpha 0,55** en plus du badge (lisibles et tappables — l'édition d'un archivé doit rester possible). **Miroir web** : `treatmentsForDisplay` dans `js/data/models.js` (node-safe, pas de DOM) + rendu sections + `opacity:0.55` + clés i18n `inactive_section` FR/EN. Tests : **5 JVM** (`TreatmentsDisplayTest` : regroupement, stabilité, tout-actif, tout-inactif, vide) + **4 web** (`tests/treatments-display.test.js`) — pas de test UI instrumenté pour l'en-tête (dépendrait de données inactives, contre la convention data-indépendance §8.ter) : couverture JVM + validation émulateur (5 actifs en haut, en-tête + EV-old/EEn-old tout en bas, dumps tr1/tr2). 264 tests JVM + lint ; web 184 tests + E2E verts (check.sh). |
|
||||
| 28 sept. 2026 (session v1.10.1) | **Durcissement rappels — revue de code post-v1.10.0** (audit demandé : « optimisations ou problèmes, web et Android »). (a) **`launchMode="singleTop"`** : le combo `standard`+`CLEAR_TOP` recréait l'activité au tap notification app-ouverte et rendait le `onNewIntent` de la v1.10.0 inopérant (code mort) — désormais délivré SANS recreation (état UI préservé). (b) **`EXTRA_PLANNED_AT`** : le garde « créneau déjà honoré » évaluait le jour au moment du FEU — une alarme inexacte (`setWindow`/Doze) glissant 23:58→00:02 évaluait le mauvais jour ; l'instant planifié voyage dans l'intent (scheduleFor), le snooze le FORWARDE, le garde évalue le jour du CRÉNEAU ; vérifié émulateur (broadcast `planned_at` hier → notif sautée). (c) **`BootReceiver` consolidé** (dette §20.bis #2 FAIT) : `goAsync`+coroutine, `runBlocking` supprimés. (d) Style (import `mutableStateOf`) + audit doc (comptes 223 résiduels §14/#64 et §16.ter → 259 ; §9 et §20.bis à jour). Web NON concerné (miroir lab-timing laissé tel quel — boucle correcte et testée ; `importJson` par lots reste en dette). 259 tests JVM + 14 UI + lint verts. **Publication** : commit d531eca + tag v1.10.1 poussés sur les 2 Gitea, APK release (2,7 Mo) + debug (21 Mo) publiés et vérifiés par téléchargement (cloudyfy id 78, farewell id 1588586) ; validation §16.ter sur l'APK RELEASE AVANT tag (accueil + données, singleTop, planned_at A/B, 0 crash). |
|
||||
| 27-28 sept. 2026 (session v1.10.0) | **2 fixes + 1 amélioration rappels** (remontées + nouvelles données réelles → 6ᵉ régression épinglée `backup-v1.9.8.json`). (a) **#68 — reco de prise de sang antérieure à la stabilisation** : le « creux » = minimum de la FENÊTRE ENTIÈRE tombait juste après l'injection PRÉCÉDENTE pour les esters à montée lente (EEn pic ~J+5 ≈ intervalle 7 j → creux d'absorption ~3 h post-injection) — date gouvernée par l'injection N−1 (antérieure à la stab) et « juste avant ton injection du … » faux de plusieurs jours (réel : creux 5 oct 02:32 < stab 7 oct 04:03). FIX : creux = niveau PRÉ-INJECTION du créneau (restaure le principe v1.8.0 documenté ; EV inchangé — le point pré-injection EST son min de fenêtre) ; **miroir web appliqué** (lab-timing.js). Tests : RegressionUserCase6Test data-driven dont balayage de `now` ±60 j (invariant « creux ≥ stab » à TOUT INSTANT) ; les 17 LabTimingTest passent inchangés. (b) **#69 — dialog fantôme** : tap notification → dialog ; le fermer + changer d'onglet + revenir sur l'accueil le ROUVRAIT à chaque fois (paramètre d'activité vs consommation dans les remember de Home, détruits à chaque sortie d'onglet — reproduit sur émulateur AVANT fix). FIX : `MutableState<Long?>` détenu par MainActivity, consommé UNE fois (extras retirés de l'intent après lecture ; bonus : tap notification app-ouverte ouvre aussi le dialog). Test UI `LogDoseRequestTest` + vérification émulateur. (c) **Rappel sauté si dose déjà loggée** (demande) : garde au déclenchement — `hasDoseLoggedOnDay` (pur, jour calendaire LOCAL) dans ReminderReceiver → notif sautée + re-programmation créneau suivant dans tous les cas ; 6 tests JVM + vérification A/B émulateur (EEn dose-du-jour → 0 notif, Fluoxetine sans dose → 1 notif). **259 tests JVM + 14 UI + lint** ; **web 180 tests + E2E verts** (check.sh). **Publication** : commit a4f859f + tag v1.10.0 poussés sur les 2 Gitea, APK release (2,7 Mo) + debug (21 Mo) publiés et vérifiés par téléchargement (cloudyfy id 77, farewell id 1588583). **Web miroir v1.10.0 sync** (fix #68 lab-timing, WEB_VERSION alignée, commit b865b16 + tag poussés ; #69/garde rappel = Android-only, notés dans le changelog web). |
|
||||
| 22 sept. 2026 (session v1.9.8) | **Socle qualité : tests UI Compose + signature release dédiée + découpage Settings** (revue de code du 21 sept. : « pas de CI, pas de tests UI, APK signé clé debug, écrans qui grandissent »). (a) **13 tests UI instrumentés** (`app/src/androidTest/uitest/`, §8.ter) : navigation 5 onglets (preuves = éléments inconditionnels : chips 24 h, FAB), dialog Nouveautés (épinglage du fix v1.3.2 : ne réapparaît pas après dismiss+restart), sections Paramètres + version installée = BuildConfig (le bug #46 ne peut plus revenir) ; déterminisme = pm grant shell pré-launch + markChangelogSeen + assertions via targetContext (indépendant FR/EN) + zéro dépendance aux données Room ; deps androidTest (BOM + ui-test-junit4 + ext:junit-ktx + junit explicite). (b) **Signature release conditionnelle** (§16.quater) : `scripts/make-release-keystore.sh` (shellcheck+shfmt) génère keystore + keystore.properties (gitignorés), `assembleRelease` l'utilise s'il existe, sinon fallback clé debug inchangé ; migration backup→désinstall→réimport documentée. (c) **SettingsScreen découpé** (840 → 377 + 11 fichiers 33–164 lignes dans `ui/screens/settings/`, §10) — déplacement pur, commentaires historiques conservés, ChartScreen volontairement entier (garde de source #54). **Vérifications** : 249 tests JVM + 13 UI verts, lint vert, assembleDebug/Release OK, **smoke test RELEASE émulateur** (accueil, 5 onglets, Paramètres complet scroll compris — version 1.9.8 visible, éditeur traitement, dialog dose + garde « crée un traitement », 0 crash logcat — anti-#64). **README EN** (README.en.md, liens FR/EN croisés ; DEVELOPPEMENT.md reste FR par choix assumé). **Publication** : commit 09cddfc + tag v1.9.8 poussés sur les 2 Gitea, APK release (2,7 Mo) + debug (21 Mo) publiés et vérifiés par téléchargement (cloudyfy id 75, farewell id 1588581). Web miroir NON concerné (v1.9.8 = socle Android uniquement : tests instrumentés, signature APK, découpage Compose, README du dépôt Android — rien à porter côté web, qui reste à v1.9.7). |
|
||||
@ -266,7 +264,6 @@ simulation de tout l'historique EV disparaissait) :
|
||||
| ✅ Retiré des chips « Log rapide » (accueil) | `HomeScreen` → `activeTreatments` |
|
||||
| ✅ Retiré du dropdown des **nouvelles** doses | `DosesScreen` : création → actifs only ; **édition → tous** (une dose existante reste rattachée à son traitement inactif) |
|
||||
| ✅ Rappels annulés (au save, au boot, au calcul de « prochaine dose ») | `rescheduleAll` + `nextReminderFireMs` (filtre `isActive`) ; `BootReceiver` lit `getAllOnce()` pour annuler les alarmes des inactifs |
|
||||
| ✅ **Plus AUCUN créneau prévisionnel (v1.12.0, fix #70)** | `generateForecastDoses` garde `!isActive` — ni graphique Prévision, ni extension de fenêtre, ni horizon LabTiming ; le chip Prévision du graphique ne considère que les Posologies ACTIVES |
|
||||
| ❌ JAMAIS retiré de la simulation | Home/Chart passent **`allTreatments`** au moteur — les écrans ne filtrent jamais |
|
||||
| ❌ JAMAIS retiré de la calibration (auto) | `autoCalibrated(allTreatments, …)` |
|
||||
| ❌ JAMAIS supprimé de l'historique des doses | `DosesScreen` liste tout, suppression manuelle uniquement |
|
||||
@ -634,27 +631,16 @@ prévisionnel STABILISÉ** — deux idées pharmacocinétiques :
|
||||
2. un creux n'interprétable que si le régime est **stabilisé** : 5 × t½
|
||||
terminale après le dernier changement (≈ 97 % de l'équilibre).
|
||||
|
||||
**v1.13.0 — le suivi s'appuie sur un système à TROIS niveaux distincts** :
|
||||
|
||||
| Niveau | Rôle | Notifications |
|
||||
|---|---|---|
|
||||
| Seuils d'alerte (§9.bis, `pk/Alerts.kt`) | surveiller le niveau estimé **en continu** | ✅ carte accueil + worker 15 min |
|
||||
| **Cible de creux** (v1.13.0, opt-in) | référence **de lab** : « au creux recommandé, je veux être dans [basse, haute] » | ❌ jamais — lecture seule |
|
||||
| Reco de prise de sang (cette section) | **quand** tester + **combien attendre** (`predictedE2`, v1.13.0) | — |
|
||||
|
||||
Les bandes sont volontairement indépendantes (ex. réelles : alertes
|
||||
210–350, cible de creux 150–200 — la cible basse est SOUS l'alerte basse,
|
||||
les fusionner serait faux).
|
||||
|
||||
- **Traitement porteur** : ESTRADIOL + injectable (`usesProfileModel`) +
|
||||
**actif** + Posologie > 0. Sinon `null` → carte cachée ; et si un
|
||||
injectable E2 actif est SANS Posologie, l'UI affiche l'**invite**
|
||||
([LabTiming.shouldSuggestPosology], demande v1.8.0 : rendre découvrable le
|
||||
lien Posologie → recommandation). Les deux encarts sont exclusifs.
|
||||
- **t½ terminale** : TFS/WHSAH **analytiques** (`terminalHalfLifeDays`) ;
|
||||
**Estrannaise analytique** depuis v1.9.0
|
||||
([EstrannaiseModels.terminalHalfLifeDays] — forme close estrannaise.js ;
|
||||
l'ancienne lecture de table `PKProfileStore` est HORS runtime, cf §7.12).
|
||||
- **t½ terminale** : TFS/WHSAH analytiques (`terminalHalfLifeDays`) ;
|
||||
**Estrannaise** : lue dans la table par
|
||||
[PKProfileStore.terminalHalfLifeDays] (refactor v1.8.0 : la pente
|
||||
log-linéaire utilisée par l'extrapolation de `sample()` — dernier point
|
||||
≥ 1 % du pic, 48 h précédentes — est partagée).
|
||||
- **Début du régime courant** (v1.8.1, **correction du proxy v1.8.0** —
|
||||
critique : « changé d'ester, de dosage ET de posologie, et l'app disait
|
||||
stabilisée depuis février ») : le régime courant = la **séquence terminale
|
||||
@ -664,15 +650,7 @@ les fusionner serait faux).
|
||||
exacte v1.8.1 cassait le régime à chaque variation d'heure de log et
|
||||
faisait fuir le creux recommandé ; « je m'injecte le même jour, à l'heure
|
||||
près » — un vrai changement de créneau, ex. 2 j au lieu de 7 j, reste
|
||||
hors fenêtre). **v1.13.0 : séquence POOLÉE entre traitements**
|
||||
([LabTiming.pooledRegimeDoses]) — les doses de tous les traitements
|
||||
partageant (ester effectif, mg) forment UNE séquence : le re-parenting
|
||||
d'historique (« … - old » créé a posteriori, remontée v1.12.0) ne fait
|
||||
plus redémarrer la stabilisation. Garde-fous : ester ≠ → jamais poolé
|
||||
(transition EV→EEn, régression n°3) ; dose ≠ → exclue (le 8 mg casse le
|
||||
régime via le trou qui suit — conservateur). Sur la data réelle de la
|
||||
remontée : régime = 12 août (« stable depuis ») au lieu de « pas
|
||||
stabilisée avant ~20 oct ». Stabilisation = régimeStart +
|
||||
hors fenêtre). Stabilisation = régimeStart +
|
||||
5 × t½. Conservative assumée : des intervalles chaotiques maintiennent la
|
||||
carte « non stabilisée » (pharmacocinétiquement vrai — le trough n'est
|
||||
comparable que sur un intervalle régulier).
|
||||
@ -691,14 +669,6 @@ les fusionner serait faux).
|
||||
recommander un creux déjà mesuré) ; **creux ≥ stabilisation** (sinon
|
||||
creux du créneau suivant — décision v1.8.0 « sauter » ; depuis #68 le
|
||||
garde s'exprime sur le creux lui-même, instant réellement proposé).
|
||||
- **Valeur prédite + cible (v1.13.0)** : `LabRecommendation.predictedE2`
|
||||
= valeur brute du modèle au creux × facteur du ester actif
|
||||
(`scalePerEster` optionnel, fourni par Home/Labs quand l'auto-cal est ON ;
|
||||
`null` → la carte n'affiche RIEN — une valeur brute non calibrée serait
|
||||
trompeuse) ; statut face à la cible de creux personnelle via
|
||||
[LabTiming.troughTargetStatus] (IN_TARGET/BELOW/ABOVE, bornes incluses,
|
||||
`null` si cible absente) → coloration primaire (dans la cible) /
|
||||
tertiary (hors) + suffixe « dans/hors de ta cible ».
|
||||
- **UI** : LabsScreen — calcul `produceState` (Dispatchers.Default) + tick
|
||||
minute ; carte avec creux exact (« At the estimated trough »), créneau
|
||||
associé (+ mention « ou simplement la veille »), statut de stabilisation,
|
||||
@ -785,7 +755,7 @@ devient à son tour**.
|
||||
|
||||
## 8. Tests unitaires
|
||||
|
||||
**284 tests JVM, tous verts** (`./gradlew testDebugUnitTest`) — **250 sans
|
||||
**264 tests JVM, tous verts** (`./gradlew testDebugUnitTest`) — **230 sans
|
||||
les données de test locales** (cf §8.bis : les 6 classes de régression sont
|
||||
skippées via `Assume`). Dépendance : JUnit 4.13.2.
|
||||
Emplacement : `app/src/test/java/com/hormonetrack/`. Répertoire de travail d'exécution =
|
||||
@ -994,8 +964,8 @@ dépôt (ni maintenant, ni si le repo devient public un jour).
|
||||
|
||||
- emplacement : `local-test-data/backup-v1.0.0.json`, `backup-v1.2.0.json`,
|
||||
`backup-v1.2.3.json` (ancien export, plus consommé par un test),
|
||||
`backup-v1.3.1.json`, `backup-v1.4.2.json`, `backup-v1.7.0.json`, `backup-v1.9.8.json` et
|
||||
`backup-v1.12.0.json`
|
||||
`backup-v1.3.1.json`, `backup-v1.4.2.json`, `backup-v1.7.0.json` et
|
||||
`backup-v1.9.8.json`
|
||||
(copiés tels quels depuis l'export JSON de l'app) ;
|
||||
`RegressionUserCaseTest` lit v1.0.0,
|
||||
`RegressionUserCase2Test` lit v1.2.0, `RegressionUserCase3Test` lit
|
||||
@ -1004,10 +974,7 @@ dépôt (ni maintenant, ni si le repo devient public un jour).
|
||||
traitements dont CPA oral ; paire E2+T avec DEUX notes distinctes —
|
||||
épine le fix « une note sur deux » v1.7.1), `RegressionUserCase6Test` lit
|
||||
**v1.9.8** (profil à 7 traitements, logs à heures variables ; épine le
|
||||
fix #68 « creux avant stabilisation » — invariant balayé sur `now` ±60 j),
|
||||
`RegressionUserCase7Test` lit **v1.12.0** (export avec re-parenting
|
||||
« 6d-old » — épine le régime POOLÉ v1.13.0 : le régime doit traverser la
|
||||
frontière de re-parenting et rester arrêté par la dose de mg différent) ;
|
||||
fix #68 « creux avant stabilisation » — invariant balayé sur `now` ±60 j) ;
|
||||
- `.gitignore` contient `local-test-data/` → jamais commités.
|
||||
**GARDES DE CONFIDENTIALITÉ (rappel 7 sept. 2026, à chaque release)** :
|
||||
1. `git check-ignore -v local-test-data/…` → la règle matche ;
|
||||
@ -1021,9 +988,9 @@ dépôt (ni maintenant, ni si le repo devient public un jour).
|
||||
dans le code (le scanner refuserait, et ce serait une fuite).
|
||||
- les tests font `Assume.assumeTrue(file.exists())` dans le `@Before` : **sans le
|
||||
fichier, la classe est IGNORÉE** (skipped, pas failed) — un clone neuf ou une CI
|
||||
exécute 250 tests au lieu de 284 (v1.13.0 ; chiffres historiques : 44/87 à v1.3.x,
|
||||
exécute 230 tests au lieu de 264 (v1.11.0 ; chiffres historiques : 44/87 à v1.3.x,
|
||||
150/172 à v1.4.x, 160/183 à v1.5.0, 168/191 à v1.6.0, 177/200 à v1.7.0,
|
||||
181/211 à v1.7.1, 190/220 à v1.8.0, 219/249 à v1.9.x, 225/259 à v1.10.x, 230/264 à v1.11.x, 240/274 à v1.12.x) ;
|
||||
181/211 à v1.7.1, 190/220 à v1.8.0, 219/249 à v1.9.x, 225/259 à v1.10.x) ;
|
||||
- le workdir des tests Gradle est le dossier du module (`app/`) → les tests
|
||||
cherchent les fichiers à plusieurs chemins (`../local-test-data/…` en premier) ;
|
||||
- **pour les lancer** : exporter un backup JSON depuis l'app → l'enregistrer sous
|
||||
@ -1159,11 +1126,6 @@ Sur la montre : remontée par Gadgetbridge **ou** Huawei Health (cf §17).
|
||||
|
||||
### 9.bis Alertes de seuil : `reminder/AlertNotifier.kt` + worker (v1.4.2)
|
||||
|
||||
> ⚠️ À NE PAS CONFONDRE avec la **cible de creux** (v1.13.0, §7.11) : les
|
||||
> seuils ci-dessous surveillent le niveau estimé EN CONTINU et notifient ;
|
||||
> la cible de creux est une référence de lab évaluée en lecture seule sur
|
||||
> la carte reco — elle ne notifie jamais.
|
||||
|
||||
- **Seuils** (`pk/Alerts.kt`, PUR) : `Thresholds` (E2 haut/bas pg/mL, T haut/bas
|
||||
ng/mL, null = pas de limite), évaluation STRICTE (valeur == limite → rien),
|
||||
`evaluateAll` (E2 puis T), validation haut > bas (`isCoherent`).
|
||||
@ -1228,11 +1190,7 @@ Sur la montre : remontée par Gadgetbridge **ou** Huawei Health (cf §17).
|
||||
- `DosesScreen` : LazyColumn par jour (desc), **Δ jours depuis la dose précédente du même
|
||||
traitement** (`intervalsByDoseId`, colonne « Interval (d) » du `.ods`), suppression
|
||||
avec confirmation, FAB → `DoseDialog` (création), **tap sur la ligne → édition** ;
|
||||
**v1.12.0** : **icône de forme de prise** en tête de ligne (`routeIcon` pur —
|
||||
pilule/seringue IM+SC teinte tertiary pour SC/goutte/sparadrap/compte-gouttes)
|
||||
et **encart latéral « prise de sang le même jour »** (`labMarkersForDose` pur —
|
||||
🧪↑ avant la dose, 🧪↓ après ; jour calendaire LOCAL, lab à l'heure exacte =
|
||||
APRÈS) ; **en-tête « temps sous THS »** (v1.3.1) : carte depuis la 1re prise, jours
|
||||
**en-tête « temps sous THS »** (v1.3.1) : carte depuis la 1re prise, jours
|
||||
totaux + décomposition mois/jours (`HrtDuration`, mois = 30 j estimés)
|
||||
- `LabsScreen` (v1.2.2) : **prise de sang E2 + T en une entrée** (LabDialog create :
|
||||
deux sections optionnelles → 1 ou 2 LabResult au même timestamp) ; affichage
|
||||
@ -1285,7 +1243,7 @@ Sur la montre : remontée par Gadgetbridge **ou** Huawei Health (cf §17).
|
||||
**« Calibration automatique (E2 + T) » — UNE option** (par période d'ester + modèle T,
|
||||
v1.2.1, désactivée par défaut) puis réglages T manuels (base/floor/k + bouton
|
||||
« Calibrer avec les analyses » ponctuel) ; statut alarmes exactes + bouton d'octroi ;
|
||||
Export/Import JSON ; auto-backup (v1.7.0) ; **carte « Cible de creux » (v1.13.0, opt-in — référence de lab distincte des seuils d'alerte, hint croisé)** ; logs ; à propos.
|
||||
Export/Import JSON ; auto-backup (v1.7.0) ; logs ; à propos.
|
||||
⚠️ **`ChartScreen` (790 lignes) reste volontairement ENTIER** : sa garde de
|
||||
source (`ChartScreenSourceGuardTest`, fix #54) exige que le bloc
|
||||
`detectTransformGestures` ET les alias `gesture*` vivent dans CE fichier —
|
||||
@ -1378,10 +1336,7 @@ Pièges :
|
||||
restauré dans DataStore, **les paramètres utilisateur sont restaurés**
|
||||
(v1.4.2 : auto-calibration, seuils d'alerte, langue — la LANGUE est
|
||||
appliquée sur le thread MAIN car `setApplicationLocales` recrée
|
||||
l'activité ; **v1.13.0 : cible de creux** `troughTargetLow`/`High`
|
||||
restaurée SEULEMENT si le backup en porte une cohérente (haut > bas) —
|
||||
un backup ancien n'efface pas la cible locale) et les rappels sont
|
||||
reprogrammés (`rescheduleAll`). Le dialog prévient que TOUT sera
|
||||
l'activité) et les rappels sont reprogrammés (`rescheduleAll`). Le dialog prévient que TOUT sera
|
||||
remplacé (bouton « Effacer & restaurer »)
|
||||
- Transport : SAF (`CreateDocument("application/json")` / `OpenDocument`), écriture
|
||||
`openOutputStream(uri, "wt")` ; ⚠️ pas de `return` dans un expression body `= try{}`
|
||||
@ -1915,19 +1870,6 @@ app-ouverte ouvre désormais aussi le dialog. Leçon : une demande à consommer
|
||||
fois doit vivre à la MÊME durée de vie que sa consommation — jamais « paramètre
|
||||
longue-vie + effet courte-vie ». Épinglé par le test UI LogDoseRequestTest.
|
||||
|
||||
**#70 (v1.12.0) — inactif à Posologie projetait encore ses injections** :
|
||||
`generateForecastDoses` (source unique des créneaux prévisionnels) ne vérifiait
|
||||
pas l'archivage — un injectable INACTIF avec Posologie et de l'historique
|
||||
continuait d'alimenter le graphique Prévision, l'extension de fenêtre et
|
||||
l'horizon LabTiming ; accessoirement le chip Prévision s'activait sur des
|
||||
Posologies inactives. FIX : garde `!isActive` dans le moteur + horizon/chip sur
|
||||
les ACTIFS. Cohérence d'ensemble (§6.bis) : l'INACTIF garde son historique
|
||||
simulé/calibré mais ne projette plus rien — exactement comme ses rappels
|
||||
(v1.4.0). Leçon : quand un état administratif gouverne DÉJÀ une consommation
|
||||
d'une source (rappels), vérifier les AUTRES consommateurs de la même source.
|
||||
Épinglé par ForecastDosesGuardTest (3 tests : inactif vide, actif inchangé,
|
||||
avant/après archivage).
|
||||
|
||||
## 15.bis Comment régénérer l'asset mcmc_samples.json (v1.9.0)
|
||||
|
||||
L'asset `src/main/assets/mcmc_samples.json` (posterior MCMC de
|
||||
@ -2100,8 +2042,8 @@ de signature est requise — elle est désormais câblée :
|
||||
|
||||
1. **Bumper la version** dans `app/build.gradle.kts` : `versionCode = N+1`,
|
||||
`versionName = "X.Y.Z+1"` (SemVer : fix = Z, feature = Y).
|
||||
2. **Tests verts obligatoires** : `./gradlew testDebugUnitTest` — 284 au
|
||||
total, 250 si `local-test-data/` est absent (les 6 classes de régression
|
||||
2. **Tests verts obligatoires** : `./gradlew testDebugUnitTest` — 264 au
|
||||
total, 230 si `local-test-data/` est absent (les 6 classes de régression
|
||||
réelles sont skippées via `Assume`) ; **lint vert
|
||||
obligatoire** : `./gradlew lint` (v1.3.4 — `StringFormatMatches` aurait
|
||||
attrapé les crashs #47/#48 dès v1.3.1).
|
||||
@ -2401,14 +2343,6 @@ Sur le téléphone de test (à compléter par l'utilisatrice) :
|
||||
- [ ] **v1.11.0** : page Traitements — les inactifs sont TOUT EN BAS sous
|
||||
l'en-tête « Traitements inactifs », cartes atténuées ; éditer un
|
||||
inactif fonctionne toujours
|
||||
- [ ] **v1.12.0** : archiver un injectable à Posologie → plus AUCUN créneau
|
||||
projeté (chip Prévision : ses injections disparaissent de la projection)
|
||||
- [ ] **v1.12.0** : page Doses — chaque ligne porte l'icône de sa forme
|
||||
(pilule/seringue/goutte/sparadrap) ; une dose du jour d'une prise de
|
||||
sang affiche l'encart 🧪↑ et/ou 🧪↓
|
||||
- [ ] **v1.13.0** : auto-calibration ON → la carte reco affiche « ≈ X pg/mL » ;
|
||||
régler une Cible de creux (Paramètres) → la prédiction est colorée
|
||||
dans/hors cible (jamais de notification — cf §7.11/§9.bis)
|
||||
- [ ] **v1.2.x** : graphique panoramique (glisser → passé, bouton « Revenir à maintenant »)
|
||||
- [ ] **v1.2.x** : toggles Estrannaise/TFS indépendants (les deux courbes superposées)
|
||||
- [ ] **v1.2.x** : chip « Prévision » (configurer la Posologie d'un traitement d'abord)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user