Traverser et aplatir récursivement l'objet JSON dans DataWeave

Nov 19 2020

Je veux parcourir et aplatir un gros fichier JSON qui a la structure suivante montrant une hiérarchie de produits (pensez-y comme navigation dans une boutique en ligne):

productGroups: [
    {
        "key": "child 1"
        ...
        "childrenProductGroups": [
            {
                "key": "child 1.1",
                ...,
                "childrenProductGroups": []
            },
            {
                "key": "child 1.2"
                ...
                "childrenProductGroups": [
                    {
                        "key": "child 1.2.1",
                        ...,
                        "childrenProductGroups": [
                            {
                                "key": "child 1.2.1.1",
                                ...,
                                childrenProductGroups": [
                                    ...
                                ]
                            }
                        ]
                    },
                    {
                        "key": "child 1.2.2",
                        ...,
                        "childrenProductGroups": []
                    }
                ]
                
            },
            {
                "key": "child 1.3",
                ...,
                "childrenProductGroups": [
                    ...
                ]
            }
        ]
    }, 
    {
        "key": "child 2",
        ...,
        "childrenProductGroups": [
            ...
        ]
    },
    {
        "key": "child 3",
        ...,
        "childrenProductGroups": [
            ...
        ]
    }
]

Et je veux les aplatir dans un format comme celui-ci:

{
    "hierarchieSet": [
        {
            "Nodeid": "00000001", # Number in this json
            "Nodename": "child 1",
            "Tlevel": "01", # First child of product group
            "Parentid": "00000000", # Parent is null
            "Childid": "00000002", # Child node number
            "Nextid": "00000008" # Node number on the same level (child 2)
        }, 
        {
            "Nodeid": "00000002",
            "Nodename": "child 1.1",
            "Tlevel": "02",
            "Parentid": "00000001",
            "Childid": "00000003",
            "Nextid": "00000003"
        }, 
        {
            "Nodeid": "00000003",
            "Nodename": "child 1.2",
            "Tlevel": "02",
            "Parentid": "00000002",
            "Childid": "00000005",
            "Nextid": "00000007"
        }, 
        {
            "Nodeid": "00000004",
            "Nodename": "child 1.2.1",
            "Tlevel": "03",
            "Parentid": "00000003",
            "Childid": "0000005",
            "Nextid": "00000006"
        }
        , 
        {
            "Nodeid": "00000005",
            "Nodename": "child 1.2.1.1",
            "Tlevel": "04",
            "Parentid": "00000004",
            "Childid": "0000000", #No more children
            "Nextid": "00000000"
        }, 
        {
            "Nodeid": "00000006",
            "Nodename": "child 1.2.2",
            "Tlevel": "03",
            "Parentid": "00000003",
            "Childid": "0000000",
            "Nextid": "00000000"
        }, 
        {
            "Nodeid": "00000007",
            "Nodename": "child 1.3",
            "Tlevel": "02",
            "Parentid": "00000001",
            "Childid": "0000000",
            "Nextid": "00000000"
        }, 
        {
            "Nodeid": "00000008",
            "Nodename": "child 2",
            "Tlevel": "01",
            "Parentid": "00000000",
            "Childid": "0000009", # 00000009 not shown
            "Nextid": "00000014" # 
        }, 
        ...
        {
            "Nodeid": "000000014",
            "Nodename": "child 3",
            "Tlevel": "01",
            "Parentid": "00000000",
            "Childid": "00000015",
            "Nextid": "00000000" # 00000010 does not exist
        }
    ]
}

Ainsi, j'ai identifié quelques préoccupations principales:

Récursivité de l'arborescence
Transformer les éléments
Aplatir la structure
Suivre les parents, frères et sœurs et enfants
Suivi du niveau de récursivité
Formatage des nombres

J'ai essayé de résoudre ce problème par 2 approches différentes:

Utilisez DataWeave pour transformer tous les éléments
Utilisez Java pour parcourir la structure

Comme je suis assez nouveau dans la programmation fonctionnelle, je me suis davantage concentré sur l'implémentation Java, mais j'ai rencontré un certain nombre de problèmes.

Approche Java

Lisez json> Init Tree var et attribuez l'instance Java> pour chaque élément du tableau de niveau supérieur invoke traverse(data, level)dans Tree.java.
Tree.java:

import org.json.JSONObject;

public class Tree {
    private int id = 0;
    private List<Node> nodes = new ArrayList<Node>();
    
    public Tree() {
        nodes.add(new Node("01", "00000001", "HOME", "01", "00000000", "00000002", "00000000"));
    }
    
    public void traverse(String data, int level) {
        System.out.println(data);
        // TODO parse json
    }
    
    private void visit(JSONObject parent, JSONObject node, int level) {
        id++;
        nodes.add(new Node("01", String.valueOf(id), node.getString("key"), String.valueOf(level), "", "", ""));
    }
    
    public List<Node> getNodes() {
        return nodes;
    }

    private static class Node {
        private String zshop, nodename, parentid, childid, nextid, nodeid, tlevel;
        
        public Node(String zshop, String nodeid, String nodename, String tlevel, String parentid, String childid, String nextid) {
            this.zshop = zshop;
            this.nodeid = nodeid;
            this.nodename = nodename;
            this.tlevel = tlevel;
            this.parentid = parentid;
            this.childid = childid;
            this.nextid = nextid;
        }
    }
}

Lors de l'appel de l'action invoke, j'utilise cette charge utile:

%dw 2.0
output application/java
---
{
    data: vars.rootMessage.payload as String,
    level: 1
}

Mais cela génère l'erreur suivante:

"Impossible de forcer Object {encoding: UTF-8, mediaType: text / json; charset = UTF-8, mimeType: text / json, raw: org.mule.weave.v2.el.SeekableCursorStream@50ecee52} (org.mule. weave.v2.el.MuleTypedValue@511ba9cc) en chaîne

5 | data: vars.rootMessage.payload as String, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Trace: at main (line : 5, colonne: 7) "expression d'évaluation:"% dw 2.0 output application / java --- {data: vars.rootMessage.payload as String, level: 1} ".

J'ai essayé un certain nombre de choses:

Lancez-le sur un ProductGroupobjet que j'ai écrit en Java
Essayez de caster l'objet récupéré vers org.json.JSONObject
Essayez de mettre en mémoire tampon et de lire vars.rootMessage.payload (Binary)

Mais je n'ai pas pu le résoudre avec aucun de ces problèmes.

Approche DataWeave Mon script .dw

%dw 2.0
fun append
(item: Object, acc: Object = {
}) = acc ++ item

fun mapper(item: Object) = 
{
    Zshop: "01",
    Nodeid: "00000000",
    Nodename: item.key as Number as String {format: ""},
    Tlevel: "02",
    Parentid: "00000000",
    Childid: "00000000",
    Nextid: "00000000"
}
    
fun traverse(a: Array, level: Number) = 
    a map $ flatMap(value, index) -> value
    
output application/json
---
{
    test: payload.productGroups reduce (item, acc) -> append(mapper(item), acc)
}

Où j'ai essayé de résoudre certains des problèmes. mapper(item)devrait créer des objets json que je peux ajouter à la sortie finale avec appender(item, acc). La récursivité a été esquissée, mais ce n'est pas encore ma principale préoccupation.

Traverser et aplatir récursivement l'objet JSON dans DataWeave

Réponses