Utilisation avancée des grilles et formulaires

Dokos introduit des améliorations significatives dans la gestion des données au sein des grilles (tableaux) et des formulaires, notamment pour les champs de type tableau (TableField) et les formulaires dynamiques (FormLayout). Ces changements permettent une meilleure traçabilité des modifications et une gestion plus intuitive des lignes dans les tableaux.

Nouveaux mécanismes de commit

Commit des champs au point de modification

Auparavant, les modifications apportées dans un champ de formulaire n'étaient pas immédiatement identifiables comme "validées" par l'utilisateur. Désormais, chaque champ émet un événement de commit lorsqu'une modification est considérée comme définitive (par exemple, après avoir quitté le champ ou validé avec la touche Entrée).

Exemple concret :

• Vous modifiez le nom d'un client dans un formulaire.
• Tant que vous êtes dans le champ, les modifications sont temporaires.
• Dès que vous quittez le champ (clic ailleurs, tabulation, Entrée), un commit est émis pour indiquer que cette valeur est maintenant validée.

Gestion des lignes dans les tableaux

Les tableaux (Grid) bénéficient de plusieurs améliorations pour éviter les pertes de données et clarifier les modifications :

1. Identifiants uniques pour les nouvelles lignes
   • Lorsqu'une nouvelle ligne est ajoutée à un tableau, Dokos lui attribue un identifiant temporaire (__row_id) côté client.
   • Cet identifiant persiste jusqu'à ce que la ligne soit enregistrée sur le serveur, où elle reçoit alors un name définitif.
   • Pourquoi c'est important : Cela évite les conflits lors de l'enregistrement simultané de plusieurs lignes.
2. Séparation des clés serveur et client
   • Les identifiants des lignes (name côté serveur et __row_id côté client) sont maintenant gérés dans des espaces distincts.
   • Cela garantit que les sélections de lignes dans un tableau ne sont pas perdues après un enregistrement.
3. Commit des cellules de tableau
   • Chaque cellule d'un tableau émet désormais un commit lorsqu'elle est modifiée, avec des informations précises sur la ligne et la colonne concernées.
   • Exemple : Si vous modifiez la quantité d'un article dans un tableau de commande, le commit indiquera clairement que la cellule (ligne: "ART-001", colonne: "quantite") a été mise à jour.

Impact sur les formulaires avec tableaux imbriqués

Les formulaires contenant des tableaux imbriqués (par exemple, une commande client avec un tableau d'articles) voient leur comportement amélioré :

• Champs enfants isolés : Les modifications dans un tableau enfant (ex: articles d'une commande) ne déclenchent plus de commits sous le nom du champ parent (ex: "articles"). Chaque modification est correctement attribuée à sa ligne et sa colonne.
• Dialogues d'édition des lignes : Lorsqu'une ligne est éditée via un dialogue (ex: clic sur une ligne pour modifier ses détails), les commits sont émis sous le nom du champ spécifique (ex: "quantite", "prix_unitaire") plutôt que sous le nom du tableau parent.

Exemple : Commande client avec articles

Scénario : Vous créez une commande pour le client Maison Verte SARL et ajoutez deux articles.

1. Vous remplissez les informations générales de la commande (client, date, etc.).
2. Dans le tableau Articles, vous ajoutez une ligne pour l'article Bureau Moderne avec une quantité de 2.
   • Un commit est émis pour la cellule (ligne: "nouvelle_ligne_1", colonne: "quantite") avec la valeur 2.
3. Vous modifiez ensuite le prix unitaire de cet article.
   • Un commit est émis pour la cellule (ligne: "nouvelle_ligne_1", colonne: "prix_unitaire") avec le nouveau prix.
4. Vous enregistrez la commande.
   • Les lignes reçoivent des name définitifs (ex: ART-CMD-001).
   • Les sélections de lignes sont conservées.

      
flowchart TD
    A[Début] --> B[Modification d'un champ]
    B --> C{Type de champ}
    C -->|Champ simple| D[Commit au blur/Entrée]
    C -->|Tableau| E[Commit par cellule]
    D --> F[Événement commit émis]
    E --> F
    F --> G[Fin]

    

Bonnes pratiques pour les développeurs

Si vous personnalisez l'interface ou développez des applications sur Dokos, voici comment tirer parti de ces améliorations :

Écouter les événements de commit

Pour réagir aux modifications validées par l'utilisateur, utilisez le canal de commit injecté dans FormLayout :

// Exemple : Réagir à un commit sur un champ spécifique
import { inject } from 'vue';
import { CommitChannel } from 'dokos-ui';

const commitChannel = inject(CommitChannel);

commitChannel.onCommit((fieldname, value) => {
  if (fieldname === 'quantite') {
    console.log(`Nouvelle quantité validée: ${value}`);
    // Mettre à jour un champ calculé, par exemple
  }
});

Gestion des nouvelles lignes dans les tableaux

Lors de l'ajout de nouvelles lignes dans un tableau, assurez-vous de :

1. Fournir des valeurs par défaut : Utilisez l'objet newRow pour initialiser les champs avec des valeurs par défaut.

   // Exemple : Initialiser une nouvelle ligne d'article avec une quantité par défaut
   const newRow = {
     quantite: 1,
     prix_unitaire: 0.0
   };
   

2. Gérer les identifiants temporaires : Utilisez __row_id pour référencer les lignes non encore enregistrées.

Personnalisation des dialogues d'édition

Si vous utilisez des dialogues pour éditer les lignes d'un tableau, assurez-vous que les commits sont émis sous les bons noms de champ :

// Exemple : Configuration d'un TableField
<TableField
  :parentfield="'articles'"
  :fieldname="'articles'"
  :df="df"
  :value="value"
  @commit="handleCommit"
/>

Limitations connues

• Sélection de lignes après le premier enregistrement : Une ligne ajoutée pendant la session en cours perdra sa sélection après son premier enregistrement (car __row_id est supprimé par le serveur). Ce comportement est intentionnel pour éviter les erreurs de suppression sur la mauvaise ligne.
• Champs calculés : Les commits ne déclenchent pas automatiquement le recalcul des champs dépendants. Vous devez écouter les commits et recalculer manuellement si nécessaire.

Questions fréquentes

Pourquoi mes modifications dans un tableau ne déclenchent-elles pas de commit immédiat ?

Les commits dans les tableaux sont émis lorsque vous quittez la cellule ou validez la modification (Entrée). Cela évite de surcharger le système avec des événements à chaque frappe.

Comment puis-je savoir si une ligne est nouvelle ou existante ?

• Une ligne nouvelle aura un __row_id (côté client) mais pas de name (côté serveur).
• Une ligne existante aura un name attribué par le serveur.

Puis-je désactiver le mécanisme de commit ?

Non, ce mécanisme est intégré au cœur de FormLayout et ne peut pas être désactivé. Cependant, vous pouvez ignorer les événements de commit si vous n'en avez pas besoin.