Opération sur Objet JSON

Résumé

Nom interne : JsonObjectOperation
Catégorie : Outils
Objectif : Effectuer des opérations de lecture ou d'écriture (GET, SIZE, PUT_SET, REMOVE, CLEAR) sur un objet JSON stocké dans une variable de workflow.
Type de tâche : Normale

Compatibilité

Version minimale AndroMate : 1.1.0
Version maximale AndroMate : 1.1.0
Android minimum : Android 13 (API 33)
Android maximum testé : Android 16 (API 36)
Constructeurs supportés :
- ✅ Samsung (One UI 6.x / 7.x / 8.x)
- ✅ Google Pixel (Android Stock)
- ⚠️ Autres constructeurs — non testés
Permissions requises :
- Aucune

Description détaillée

La tâche Opération sur Objet JSON opère sur un objet JSON (jo_input) stocké comme variable de workflow. Elle supporte cinq opérations sélectionnées par un code entier (jo_ops) :

Code `jo_ops`	Opération	Description
`1`	`SIZE`	Retourne le nombre de clés dans l'objet JSON
`2`	`GET`	Retourne la valeur de la clé spécifiée dans `jo_param`
`3`	`PUT_SET`	Définit ou met à jour la clé `jo_param` avec la valeur `jo_value`
`4`	`REMOVE`	Supprime la clé `jo_param` et retourne la valeur supprimée
`5`	`CLEAR`	Remplace l'objet JSON par un `{}` vide

Les opérations de mutation (PUT_SET, REMOVE, CLEAR) modifient l'objet JSON en place et écrivent l'objet mis à jour dans le contexte workflow — la variable d'origine est mise à jour.

Les opérations de lecture (GET, SIZE) ne modifient pas l'objet.

Paramètres d'entrée

Paramètre	Type	Obligatoire	Valeurs possibles	Compatibilité Android	Compatibilité AndroMate	Défaut
`jo_input`	JSONObject	Oui	Référence à une variable workflow JSONObject (ex. `$mon_json`)	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`{}`
`jo_ops`	Integer	Oui	`1` (SIZE) / `2` (GET) / `3` (PUT_SET) / `4` (REMOVE) / `5` (CLEAR)	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	—
`jo_param`	String	Non	Toute clé string — requis pour GET, PUT_SET, REMOVE — supporte les références `$variable`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`""`
`jo_value`	String	Non	Toute chaîne — requise pour PUT_SET — supporte les références `$variable`	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`""`

Paramètres de sortie

Champ	Type	Condition de déclenchement	Compatibilité Android	Compatibilité AndroMate	Défaut
`value_output`	String	Écrit lorsque l'opération produit un résultat (SIZE, GET, PUT_SET, REMOVE) — non écrit pour CLEAR	Android 13 (API 33) → Android 16 (API 36)	1.1.0 → 1.1.0	`<ANDROMATE_NULL_VALUE>`

Ce qui est écrit dans value_output selon l'opération :

Opération	Valeur écrite
`SIZE`	Nombre de clés dans l'objet JSON (en chaîne)
`GET`	La valeur de la clé demandée (en chaîne)
`PUT_SET`	La nouvelle valeur qui a été définie
`REMOVE`	La valeur qui a été supprimée
`CLEAR`	Rien n'est écrit

Remarque : value_output n'est écrit que si la variable workflow correspondante existe déjà dans le contexte d'exécution (déclarée dans la tâche Start).

Exceptions

Code	Nom de l'exception	Description
`JO-OPERATION-001`	Opération inconnue	Le code `jo_ops` ne correspond à aucune opération supportée. Codes acceptés : `1`, `2`, `3`, `4`, `5`.
`JO-OPERATION-002`	Exception objet JSON	Une erreur JSON s'est produite — clé introuvable (pour GET ou REMOVE), ou autre erreur de traitement JSON.
`ERROR-000`	Autre erreur	Une erreur runtime inattendue s'est produite pendant l'exécution.

Diagramme d'exécution

Le diagramme suivant illustre l'implémentation réelle basée sur le code Android :

flowchart TD
    Start([Démarrer JsonObjectOperationTask]) --> ResolveAll[🔄 Résoudre jo_input, jo_param, jo_value\ndepuis le contexte workflow]
    ResolveAll --> ValidateOps{Code jo_ops connu ?}
    ValidateOps -->|Non| E1[❌ JO-OPERATION-001]

    ValidateOps -->|Oui| Switch{jo_ops}

    Switch -->|code 1: SIZE| SizeOp[📐 Compter les clés\nretourner le total]
    Switch -->|code 2: GET| GetCheck{Clé présente ?}
    GetCheck -->|Non| E2[❌ JO-OPERATION-002\nClé introuvable]
    GetCheck -->|Oui| GetOp[📖 Lire la valeur\nretourner la valeur]
    Switch -->|code 3: PUT_SET| PutOp[✏️ Définir clé = jo_value\nMàj objet dans le contexte\nretourner nouvelle valeur]
    Switch -->|code 4: REMOVE| RemoveCheck{Clé présente ?}
    RemoveCheck -->|Non| E2
    RemoveCheck -->|Oui| RemoveOp[🗑️ Supprimer la clé\nMàj objet dans le contexte\nretourner valeur supprimée]
    Switch -->|code 5: CLEAR| ClearOp[🧹 Remplacer par objet vide\nMàj objet dans le contexte]

    SizeOp --> WriteOutput[💾 Écrire résultat dans value_output]
    GetOp --> WriteOutput
    PutOp --> WriteOutput
    RemoveOp --> WriteOutput
    ClearOp --> Success

    WriteOutput --> Success([✅ StrTaskResult])
    E1 --> Error([❌ Exception])
    E2 --> Error

    style Start fill:#e3f2fd
    style Success fill:#c8e6c9
    style Error fill:#ffcdd2
    style E1 fill:#ffcdd2
    style E2 fill:#ffcdd2
    style ResolveAll fill:#fff9c4
    style SizeOp fill:#f3e5f5
    style GetOp fill:#f3e5f5
    style PutOp fill:#f3e5f5
    style RemoveOp fill:#f3e5f5
    style ClearOp fill:#f3e5f5
    style WriteOutput fill:#c8e6c9

Comment ça fonctionne :

Résoudre les paramètres : jo_input, jo_param et jo_value sont résolus depuis le contexte workflow
Valider l'opération : si le code jo_ops est inconnu, lève JO-OPERATION-001
Exécuter l'opération :
SIZE : compte les clés, écrit le total dans value_output
GET : lit la valeur de jo_param, lève JO-OPERATION-002 si la clé est absente
PUT_SET : définit jo_param = jo_value, met à jour l'objet dans le contexte workflow
REMOVE : supprime jo_param, met à jour l'objet dans le contexte, lève JO-OPERATION-002 si la clé est absente
CLEAR : remplace l'objet par {}, met à jour dans le contexte workflow
Résultat : écrit la sortie dans value_output et retourne StrTaskResult

Exemples de code

Exemple 1 — GET : lire une valeur depuis un objet JSON

{
  "JsonObjectOperation": [
    {
      "id": "1",
      "title": "Lire le champ status",
      "jo_input": "$response_json",
      "jo_ops": 2,
      "jo_param": "status",
      "value_output": "$valeur_status"
    }
  ]
}

Lit la clé "status" depuis $response_json et stocke sa valeur dans $valeur_status.

Exemple 2 — SIZE : compter les champs

{
  "JsonObjectOperation": [
    {
      "id": "2",
      "title": "Compter les champs",
      "jo_input": "$mon_json",
      "jo_ops": 1,
      "value_output": "$nb_champs"
    }
  ]
}

Compte le nombre de clés de premier niveau dans $mon_json et stocke le résultat dans $nb_champs.

Exemple 3 — PUT_SET : définir une clé

{
  "JsonObjectOperation": [
    {
      "id": "3",
      "title": "Stocker le résultat de ping",
      "jo_input": "$rapport_json",
      "jo_ops": 3,
      "jo_param": "ping_result",
      "jo_value": "$ping_output",
      "value_output": "$valeur_definie"
    }
  ]
}

Définit "ping_result" avec la valeur de $ping_output dans $rapport_json. Met à jour $rapport_json dans le contexte workflow.

Exemple 4 — REMOVE : supprimer une clé

{
  "JsonObjectOperation": [
    {
      "id": "4",
      "title": "Supprimer le champ temporaire",
      "jo_input": "$mon_json",
      "jo_ops": 4,
      "jo_param": "tmp",
      "value_output": "$valeur_supprimee"
    }
  ]
}

Supprime la clé "tmp" de $mon_json. Retourne la valeur supprimée dans $valeur_supprimee.

Exemple 5 — CLEAR : vider un objet JSON

{
  "JsonObjectOperation": [
    {
      "id": "5",
      "title": "Réinitialiser le JSON",
      "jo_input": "$mon_json",
      "jo_ops": 5
    }
  ]
}

Remplace $mon_json par un {} vide.

Détails des paramètres d'entrée

1. Paramètre d'entrée : `jo_input`

Référence à la variable workflow contenant l'objet JSON sur lequel opérer. Doit être déclarée comme variable JSONObject dans la tâche Start (ex. variableValue: "{}"). Les opérations de mutation (PUT_SET, REMOVE, CLEAR) écrivent l'objet modifié dans cette variable dans le contexte workflow.

Défaut : {} (objet vide)
Supporte les variables : Oui

2. Paramètre d'entrée : `jo_ops`

Code entier sélectionnant l'opération à effectuer sur l'objet JSON.

Code	Opération	Modifie l'objet ?	Écrit dans `value_output` ?
`1`	`SIZE`	Non	Oui — nombre de clés
`2`	`GET`	Non	Oui — valeur de `jo_param`
`3`	`PUT_SET`	Oui	Oui — la nouvelle valeur définie
`4`	`REMOVE`	Oui	Oui — la valeur supprimée
`5`	`CLEAR`	Oui	Non

Défaut : — (obligatoire, pas de valeur par défaut — déclenche JO-OPERATION-001 si inconnu)

3. Paramètre d'entrée : `jo_param`

La clé de l'objet JSON sur laquelle opérer. Obligatoire pour GET, PUT_SET et REMOVE. Ignoré pour SIZE et CLEAR. Supporte les références $variable.

Défaut : ""
Supporte les variables : Oui

4. Paramètre d'entrée : `jo_value`

La valeur à assigner à jo_param lors d'un PUT_SET. Ignoré pour toutes les autres opérations. Supporte les références $variable. Toujours stocké comme String.

Défaut : ""
Supporte les variables : Oui

Détails des paramètres de sortie

1. Variable résultat : `value_output`

Stocke le résultat string de l'opération dans la variable workflow spécifiée.

Opération	Valeur écrite
`SIZE`	Nombre de clés de premier niveau (ex. `"3"`)
`GET`	Valeur de la clé `jo_param` (en chaîne)
`PUT_SET`	La nouvelle valeur qui a été définie
`REMOVE`	La valeur qui a été supprimée
`CLEAR`	(non écrit)

La variable n'est mise à jour que si elle existe déjà dans le contexte workflow (déclarée dans la tâche Start).

Exemple JSON complet

{
  "JsonObjectOperation": [
    {
      "id": "1",
      "title": "Stocker résultat ping dans le JSON",
      "jo_input": "$rapport_json",
      "jo_ops": 3,
      "jo_param": "ping_result",
      "jo_value": "$ping_output",
      "value_output": "$valeur_definie"
    }
  ]
}