tristan
45cb5c834c
Auto Tag Develop / tag (push) Successful in 8s
## Contexte (ERP-172) Sur les ecrans de **modification**, supprimer un bloc Contact / Adresse / RIB ne supprimait pas la sous-ressource cote serveur : - **M1 / M2** : DELETE differe au clic « Enregistrer » de l'onglet -> ne partait jamais si l'utilisateur ne re-validait pas. - **M3** : aucun DELETE (`splice` local uniquement). ## Correctifs ### 1. DELETE immediat des sous-ressources - Nouveau helper partage `frontend/shared/utils/collectionRow.ts` (`removeCollectionRow`) + tests Vitest. - A la confirmation de la modale : bloc existant (`id` en base) -> `DELETE` immediat ; bloc jamais persiste -> retrait local ; echec serveur (ex. 409 dernier RIB d'une LCR) -> bloc conserve + message back. - Branche sur M1 / M2 / M3 (contacts / adresses / RIB). Suppression du mecanisme differe (`removed*Ids` + boucles dans `submit*`) devenu mort. ### 2. Affichage de la poubelle unifie (`isRowRemovable`) Regle identique sur les 3 modules : poubelle visible sur un bloc **seulement s'il reste un autre bloc deja enregistre** (`id` en base). - Tant que rien n'est enregistre -> aucune poubelle (plus de suppression d'un simple brouillon non valide). - On peut jeter un brouillon non enregistre s'il reste un bloc enregistre. - On ne peut jamais supprimer son dernier bloc enregistre. - Applique aux ecrans **new + edit** des 3 modules (contacts / adresses / RIB). ## Tests - Helper couvert par Vitest (`removeCollectionRow` + `isRowRemovable`). - `make nuxt-test` : 480 tests OK. `make nuxt-lint` : OK. ## A verifier (golden path) Sur les 3 modules : supprimer un bloc existant -> `DELETE` part immediatement -> reload -> le bloc a disparu ; la poubelle n'apparait qu'avec un 2e bloc deja enregistre. Reviewed-on: #109 Co-authored-by: tristan <tristan@yuno.malio.fr> Co-committed-by: tristan <tristan@yuno.malio.fr>
80 lines
3.3 KiB
TypeScript
80 lines
3.3 KiB
TypeScript
/** Ligne de collection supprimable (contact / adresse / RIB). */
|
|
export interface DeletableRow {
|
|
id?: number | null
|
|
}
|
|
|
|
/**
|
|
* Indique si le bloc d'index `index` peut afficher sa poubelle (ERP-172).
|
|
*
|
|
* Regle metier : on ne peut supprimer un bloc QUE s'il reste au moins un AUTRE
|
|
* bloc deja enregistre (`id` non null, donc persiste en base). Consequences :
|
|
* - tant que rien n'est enregistre -> aucune poubelle (pas de suppression d'un
|
|
* simple brouillon saisi mais pas valide) ;
|
|
* - on peut jeter un brouillon non enregistre s'il reste un bloc enregistre ;
|
|
* - on ne peut jamais supprimer son dernier bloc enregistre.
|
|
*/
|
|
export function isRowRemovable<T extends DeletableRow>(rows: T[], index: number): boolean {
|
|
return rows.some((row, i) => i !== index && row.id != null)
|
|
}
|
|
|
|
/** Options de {@link removeCollectionRow}. */
|
|
export interface RemoveCollectionRowOptions<T extends DeletableRow> {
|
|
/** Tableau reactif des brouillons (passer le `.value` de la ref). */
|
|
rows: T[]
|
|
/** Tableau reactif des erreurs par ligne, aligne sur l'index (passer le `.value`). */
|
|
errors: Record<string, string>[]
|
|
/** Index de la ligne a retirer. */
|
|
index: number
|
|
/** Endpoint de la sous-ressource SANS id (ex: '/client_contacts'). */
|
|
endpoint: string
|
|
/** Suppression serveur : DOIT rejeter en cas d'echec (ex: url => api.delete(url, {}, { toast: false })). */
|
|
deleteRow: (url: string) => Promise<unknown>
|
|
/** Fabrique d'un bloc vide pour garder au moins un bloc visible apres retrait. */
|
|
makeEmpty: () => T
|
|
/** Remontee d'erreur 409/422 mappee proprement (message back, pas de toast fourre-tout). */
|
|
onError: (error: unknown) => void
|
|
}
|
|
|
|
/**
|
|
* Retire une ligne de collection (contact / adresse / RIB) sur les ecrans de
|
|
* MODIFICATION, avec DELETE immediat de la sous-ressource (ERP-172). Comportement
|
|
* aligne sur les 3 modules (Client / Fournisseur / Prestataire) :
|
|
*
|
|
* - Bloc jamais persiste (`id` null) : simple retrait local, aucun appel reseau.
|
|
* - Bloc existant (`id` non null) : DELETE `/endpoint/{id}` AVANT le retrait du
|
|
* tableau. On ne retire le bloc QUE si le serveur a confirme — sinon le bloc
|
|
* reste affiche et l'erreur est remontee via `onError` (ex. dernier RIB d'une
|
|
* LCR -> 409 back, RG-x.08).
|
|
*
|
|
* Etat purement local : `rows`/`errors` sont les `.value` des refs (proxies
|
|
* reactifs), le `splice` declenche donc la reactivite.
|
|
*
|
|
* @returns `true` si la ligne a ete retiree (suppression confirmee ou bloc local),
|
|
* `false` si la suppression serveur a echoue (bloc conserve).
|
|
*/
|
|
export async function removeCollectionRow<T extends DeletableRow>(
|
|
options: RemoveCollectionRowOptions<T>,
|
|
): Promise<boolean> {
|
|
const { rows, errors, index, endpoint, deleteRow, makeEmpty, onError } = options
|
|
const removed = rows[index]
|
|
|
|
// Bloc existant : suppression serveur d'abord, retrait local seulement si OK.
|
|
if (removed?.id != null) {
|
|
try {
|
|
await deleteRow(`${endpoint}/${removed.id}`)
|
|
}
|
|
catch (error) {
|
|
onError(error)
|
|
return false
|
|
}
|
|
}
|
|
|
|
rows.splice(index, 1)
|
|
errors.splice(index, 1)
|
|
// Garde au moins un bloc visible (cf. amorce a l'hydratation).
|
|
if (rows.length === 0) {
|
|
rows.push(makeEmpty())
|
|
}
|
|
return true
|
|
}
|