Example usage for com.fasterxml.jackson.databind.node ArrayNode add

List of usage examples for com.fasterxml.jackson.databind.node ArrayNode add

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.databind.node.*
  5. ArrayNode
  6. add

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind.node ArrayNode add.

Prototype

public ArrayNode add(JsonNode paramJsonNode)

Source Link

Usage

From source file:com.ikanow.aleph2.harvest.logstash.utils.LogstashConfigUtils.java

@SuppressWarnings("deprecation")
public static ObjectNode parseLogstashConfig(String configFile, StringBuffer error) {

    ObjectNode tree = _mapper.createObjectNode();

    // Stage 0: remove escaped "s and 's (for the purpose of the validation):
    // (prevents tricksies with escaped "s and then #s)
    // (http://stackoverflow.com/questions/5082398/regex-to-replace-single-backslashes-excluding-those-followed-by-certain-chars)
    configFile = configFile.replaceAll("(?<!\\\\)(?:((\\\\\\\\)*)\\\\)[\"']", "X");
    //TESTED (by hand - using last 2 fields of success_2_1)

    // Stage 1: remove #s, and anything in quotes (for the purpose of the validation)
    configFile = configFile.replaceAll("(?m)(?:([\"'])(?:(?!\\1).)*\\1)", "VALUE").replaceAll("(?m)(?:#.*$)",
            "");//from  w  w w  .j a va2s  .c om
    //TESTED (2_1 - including with a # inside the ""s - Event_Date -> Event_#Date)
    //TESTED (2_2 - various combinations of "s nested inside 's) ... yes that is a negative lookahead up there - yikes!

    // Stage 2: get a nested list of objects
    int depth = 0;
    int ifdepth = -1;
    Stack<Integer> ifStack = new Stack<Integer>();
    ObjectNode inputOrFilter = null;
    Matcher m = _navigateLogstash.matcher(configFile);
    // State:
    String currTopLevelBlockName = null;
    String currSecondLevelBlockName = null;
    ObjectNode currSecondLevelBlock = null;
    while (m.find()) {
        boolean simpleField = false;

        //DEBUG
        //System.out.println("--DEPTH="+depth + " GROUP=" + m.group() + " IFS" + Arrays.toString(ifStack.toArray()));
        //System.out.println("STATES: " + currTopLevelBlockName + " AND " + currSecondLevelBlockName);

        if (m.group().equals("}")) {

            if (ifdepth == depth) { // closing an if statement
                ifStack.pop();
                if (ifStack.isEmpty()) {
                    ifdepth = -1;
                } else {
                    ifdepth = ifStack.peek();
                }
            } //TESTED (1_1bc, 2_1)
            else { // closing a processing block

                depth--;
                if (depth < 0) { // {} Mismatch
                    error.append("{} Mismatch (})");
                    return null;
                } //TESTED (1_1abc)
            }
        } else { // new attribute!

            String typeName = m.group(1);
            if (null == typeName) { // it's an if statement or a string value
                typeName = m.group(4);
                if (null != typeName) {
                    simpleField = true;
                }
            } else if (typeName.equalsIgnoreCase("else")) { // It's an if statement..
                typeName = null;
            }
            if (null == typeName) { // if statement after all
                // Just keep track of ifs so we can ignore them
                ifStack.push(depth);
                ifdepth = depth;
                // (don't increment depth)
            } //TESTED (1_1bc, 2_1)
            else { // processing block
                String subTypeName = m.group(3);
                if (null != subTypeName) { // eg codec.multiline
                    typeName = typeName + "." + subTypeName;
                } //TESTED (2_1, 2_3)

                if (depth == 0) { // has to be one of input/output/filter)
                    String topLevelType = typeName.toLowerCase();
                    if (topLevelType.equalsIgnoreCase("input") || topLevelType.equalsIgnoreCase("filter")) {
                        if (tree.has(topLevelType)) {
                            error.append("Multiple input or filter blocks: " + topLevelType);
                            return null;
                        } //TESTED (1_3ab)
                        else {
                            inputOrFilter = _mapper.createObjectNode();
                            tree.put(topLevelType, inputOrFilter);

                            // Store state:
                            currTopLevelBlockName = topLevelType;
                        } //TESTED (*)
                    } else {
                        if (topLevelType.equalsIgnoreCase("output")) {
                            error.append(
                                    "Not allowed output blocks - these are appended automatically by the logstash harvester");
                        } else {
                            error.append("Unrecognized processing block: " + topLevelType);
                        }
                        return null;
                    } //TESTED (1_4a)
                } else if ((depth == 1) && (null != inputOrFilter)) { // processing blocks
                    String subElType = typeName.toLowerCase();

                    // Some validation: can't include a type called "filter" anywhere
                    if ((null != currTopLevelBlockName) && currTopLevelBlockName.equals("input")) {
                        if (subElType.equals("filter") || subElType.endsWith(".filter")) {
                            error.append("Not allowed sub-elements of input called 'filter' (1)");
                            return null;
                        }
                    } //TESTED (1_5b)

                    ArrayNode subElements = (ArrayNode) inputOrFilter.get(subElType);
                    if (null == subElements) {
                        subElements = _mapper.createArrayNode();
                        inputOrFilter.put(subElType, subElements);
                    }
                    ObjectNode newEl = _mapper.createObjectNode();
                    subElements.add(newEl);

                    // Store state:
                    currSecondLevelBlockName = subElType;
                    currSecondLevelBlock = newEl;
                } //TESTED (*)
                else if (depth == 2) { // attributes of processing blocks
                    // we'll just store the field names for these and do any simple validation that was too complicated for the regexes
                    String subSubElType = typeName.toLowerCase();

                    // Validation:
                    if (null != currTopLevelBlockName) {
                        // 1] sincedb path
                        if (currTopLevelBlockName.equals("input") && (null != currSecondLevelBlockName)) {
                            // (don't care what the second level block name is - no sincedb allowed)
                            if (subSubElType.equalsIgnoreCase("sincedb_path")) {
                                error.append("Not allowed sincedb_path in input.* block");
                                return null;
                            } //TESTED (1_5a)
                              // 2] no sub-(-sub etc)-elements of input called filter
                            if (subSubElType.equals("filter") || subSubElType.endsWith(".filter")) {
                                error.append("Not allowed sub-elements of input called 'filter' (2)");
                                return null;
                            } //TESTED (1_5c)
                        }
                    }

                    // Store in map:
                    if (null != currSecondLevelBlock) {
                        currSecondLevelBlock.put(subSubElType, _mapper.createObjectNode());
                    }
                }
                // (won't go any deeper than this)
                if (!simpleField) {
                    depth++;
                }
            }

        }
    }
    if (0 != depth) {
        error.append("{} Mismatch ({)");
        return null;
    } //TESTED (1_2a)

    return tree;
}

From source file:org.wrml.runtime.format.application.vnd.wrml.design.schema.SchemaDesignFormatter.java

private static ObjectNode buildChoicesNode(final ObjectMapper objectMapper, final Type heapValueType,
        final SchemaLoader schemaLoader) {

    if (heapValueType == null || !(heapValueType instanceof Class<?>)) {
        return null;
    }//from   w  ww .  j a  v  a 2 s . c o m

    final Class<?> choicesEnumClass = (Class<?>) heapValueType;

    if (!choicesEnumClass.isEnum()) {
        return null;
    }

    final URI choicesUri = schemaLoader.getTypeUri(choicesEnumClass);
    final String choicesName = choicesEnumClass.getSimpleName();
    final ObjectNode choicesNode = objectMapper.createObjectNode();

    choicesNode.put(PropertyName.title.name(), choicesName);
    choicesNode.put(PropertyName.uri.name(), choicesUri.toString());

    // TODO: Only embed the choices once per schema to lighten the download?
    final Object[] enumConstants = choicesEnumClass.getEnumConstants();
    if (enumConstants != null && enumConstants.length > 0) {
        final ArrayNode valuesNode = objectMapper.createArrayNode();

        choicesNode.put(PropertyName.values.name(), valuesNode);

        for (final Object enumConstant : enumConstants) {
            final String choice = String.valueOf(enumConstant);
            valuesNode.add(choice);
        }
    }

    return choicesNode;
}

From source file:com.flipkart.zjsonpatch.TestDataGenerator.java

public static JsonNode generate(int count) {
    ArrayNode jsonNode = JsonNodeFactory.instance.arrayNode();
    for (int i = 0; i < count; i++) {
        ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
        objectNode.put("name", name.get(random.nextInt(name.size())));
        objectNode.put("age", age.get(random.nextInt(age.size())));
        objectNode.put("gender", gender.get(random.nextInt(gender.size())));
        ArrayNode countryNode = getArrayNode(country.subList(random.nextInt(country.size() / 2),
                (country.size() / 2) + random.nextInt(country.size() / 2)));
        objectNode.put("country", countryNode);
        ArrayNode friendNode = getArrayNode(friends.subList(random.nextInt(friends.size() / 2),
                (friends.size() / 2) + random.nextInt(friends.size() / 2)));
        objectNode.put("friends", friendNode);
        jsonNode.add(objectNode);
    }/*from  www  .jav a  2  s  .c  om*/
    return jsonNode;
}

From source file:com.nirmata.workflow.details.JsonSerializer.java

public static JsonNode newTask(Task task) {
    RunnableTaskDagBuilder builder = new RunnableTaskDagBuilder(task);
    ArrayNode tasks = newArrayNode();
    builder.getTasks().values().forEach(thisTask -> {
        ObjectNode node = newNode();//from ww  w  .jav  a 2  s .c  om
        node.put("taskId", thisTask.getTaskId().getId());
        node.set("taskType", thisTask.isExecutable() ? newTaskType(thisTask.getTaskType()) : null);
        node.putPOJO("metaData", thisTask.getMetaData());
        node.put("isExecutable", thisTask.isExecutable());

        List<String> childrenTaskIds = thisTask.getChildrenTasks().stream().map(t -> t.getTaskId().getId())
                .collect(Collectors.toList());
        node.putPOJO("childrenTaskIds", childrenTaskIds);

        tasks.add(node);
    });

    ObjectNode node = newNode();
    node.put("rootTaskId", task.getTaskId().getId());
    node.set("tasks", tasks);
    return node;
}

From source file:com.wegas.log.neo4j.Neo4jUtils.java

/**
 * Extracts the data part from the JSON result of a query. The data is
 * returned as a list of string(s). If no data was found, an empty list is
 * returned.//from  www  .  j ava  2  s.  c o m
 *
 * @param result the result of a query
 * @return the data list as a Json object
 */
protected static ArrayNode extractListData(String result) {
    ArrayNode on = objectMapper.createArrayNode();
    ObjectMapper om = new ObjectMapper();
    try {
        JsonNode jn = om.readTree(result);
        JsonNode jnRes = jn.path("results");
        Iterator<JsonNode> ite1 = jnRes.elements();
        while (ite1.hasNext()) {
            JsonNode jn1 = ite1.next();
            JsonNode jnDat = jn1.path("data");
            Iterator<JsonNode> ite2 = jnDat.elements();
            while (ite2.hasNext()) {
                JsonNode jn2 = ite2.next();
                JsonNode jnRow = jn2.path("row");
                Iterator<JsonNode> ite3 = jnRow.elements();
                while (ite3.hasNext()) {
                    JsonNode jn3 = ite3.next();
                    on.add(jn3);
                }
            }
        }
    } catch (IOException ioe) {
        logger.debug("Error in extractListData: " + ioe.getMessage());
    }
    return on;
}

From source file:models.StockCategory.java

/**
 * Converts json tree what flat rows in database
 * /*from www .j a v a2 s  .co m*/
 * There are many repeated code blocks which same of the each other in this method, fix it
 * 
 */
public static String listAllAsJson() {
    String result = CacheUtils.getValue(StockCategory.class, "listAll");
    if (result != null)
        return result;

    List<StockCategory> rootList = new ArrayList<StockCategory>();
    Map<Integer, List<StockCategory>> level1Map = new LinkedHashMap<Integer, List<StockCategory>>();
    Map<Integer, List<StockCategory>> level2Map = new LinkedHashMap<Integer, List<StockCategory>>();
    Map<Integer, List<StockCategory>> level3Map = new LinkedHashMap<Integer, List<StockCategory>>();
    Map<Integer, List<StockCategory>> level4Map = new LinkedHashMap<Integer, List<StockCategory>>();
    Map<Integer, List<StockCategory>> level5Map = new LinkedHashMap<Integer, List<StockCategory>>();

    List<StockCategory> codeList = find.where().eq("workspace", CacheUtils.getWorkspaceId()).orderBy("name")
            .findList();

    for (StockCategory item : codeList) {
        if (item.par5Id != null) {
            arrangeItems(level5Map, item, item.par5Id);
        } else if (item.par5Id == null && item.par4Id != null) {
            arrangeItems(level4Map, item, item.par4Id);
        } else if (item.par4Id == null && item.par3Id != null) {
            arrangeItems(level3Map, item, item.par3Id);
        } else if (item.par3Id == null && item.par2Id != null) {
            arrangeItems(level2Map, item, item.par2Id);
        } else if (item.par2Id == null && item.par1Id != null) {
            arrangeItems(level1Map, item, item.par1Id);
        } else if (item.par1Id == null) {
            rootList.add(item);
        }
    }

    /**
     * Root level
     */
    ArrayNode rootAN = Json.newObject().arrayNode();
    for (StockCategory rootItem : rootList) {
        ObjectNode itemRL = Json.newObject();
        itemRL.put("key", rootItem.id);
        itemRL.put("title", rootItem.name);
        if (level1Map.containsKey(rootItem.id)) {
            itemRL.put("isFolder", true);

            /**
             * Level 1
             */
            ArrayNode level1AN = Json.newObject().arrayNode();
            List<StockCategory> level1List = level1Map.get(rootItem.id);
            for (StockCategory level1Item : level1List) {
                ObjectNode item1L = Json.newObject();
                item1L.put("key", level1Item.id);
                item1L.put("title", level1Item.name);
                if (level2Map.containsKey(level1Item.id)) {
                    item1L.put("isFolder", true);

                    /**
                     * Level 2
                     */
                    ArrayNode level2AN = Json.newObject().arrayNode();
                    List<StockCategory> level2List = level2Map.get(level1Item.id);
                    for (StockCategory level2Item : level2List) {
                        ObjectNode item2L = Json.newObject();
                        item2L.put("key", level2Item.id);
                        item2L.put("title", level2Item.name);
                        if (level3Map.containsKey(level2Item.id)) {
                            item2L.put("isFolder", true);

                            /**
                             * Level 3
                             */
                            ArrayNode level3AN = Json.newObject().arrayNode();
                            List<StockCategory> level3List = level3Map.get(level2Item.id);
                            for (StockCategory level3Item : level3List) {
                                ObjectNode item3L = Json.newObject();
                                item3L.put("key", level3Item.id);
                                item3L.put("title", level3Item.name);
                                if (level4Map.containsKey(level3Item.id)) {
                                    item3L.put("isFolder", true);

                                    /**
                                     * Level 4
                                     */
                                    ArrayNode level4AN = Json.newObject().arrayNode();
                                    List<StockCategory> level4List = level4Map.get(level3Item.id);
                                    for (StockCategory level4Item : level4List) {
                                        ObjectNode item4L = Json.newObject();
                                        item4L.put("key", level4Item.id);
                                        item4L.put("title", level4Item.name);
                                        if (level5Map.containsKey(level4Item.id)) {
                                            item4L.put("isFolder", true);

                                            /**
                                             * Level 5
                                             */
                                            ArrayNode level5AN = Json.newObject().arrayNode();
                                            List<StockCategory> level5List = level5Map.get(level4Item.id);
                                            for (StockCategory level5Item : level5List) {
                                                ObjectNode item5L = Json.newObject();
                                                item5L.put("key", level5Item.id);
                                                item5L.put("title", level5Item.name);
                                                level5AN.add(item5L);
                                            }
                                            item4L.put("children", level5AN);
                                        }
                                        level4AN.add(item4L);
                                    }
                                    item3L.put("children", level4AN);
                                }
                                level3AN.add(item3L);
                            }
                            item2L.put("children", level3AN);
                        }
                        level2AN.add(item2L);
                    }
                    item1L.put("children", level2AN);
                }
                level1AN.add(item1L);
            }
            itemRL.put("children", level1AN);
        }
        rootAN.add(itemRL);
    }

    result = Json.stringify(rootAN);
    CacheUtils.setValue(StockCategory.class, "listAll", result);

    return result;
}

From source file:org.gitana.platform.client.util.DriverUtil.java

public static ArrayNode toCopyDependencyChain(TypedID typedID) {
    ArrayNode array = JsonUtil.createArray();

    if (typedID instanceof Node) {
        array.addAll(toCopyDependencyChain(((Node) typedID).getChangeset()));
    } else if (typedID instanceof Changeset) {
        array.addAll(toCopyDependencyChain(((Changeset) typedID).getBranch()));
    } else if (typedID instanceof Branch) {
        array.addAll(toCopyDependencyChain(((Branch) typedID).getRepository()));
    } else if (typedID instanceof PlatformDocument) {
        array.addAll(toCopyDependencyChain(((PlatformDocument) typedID).getPlatform()));
    } else if (typedID instanceof PlatformDataStore) {
        array.addAll(toCopyDependencyChain(((PlatformDataStore) typedID).getPlatform()));
    }//from  w  w w .jav a2s .  c o m

    array.add(toDependencyObject(typedID));

    return array;
}

From source file:mobile.service.RNSService.java

/**
 * //from w  w  w  .  ja v a 2 s  .co  m
 *
 * @param title      
 * @param industryId Id
 * @param info       ??
 * @param budget     ??8?1??
 * @param skillsTags 
 * @param attachs    Id??
 * @return
 */
public static ServiceVOResult<CommonVO> createRequire(String title, Long industryId, String info, String budget,
        List<String> skillsTags, List<Long> attachs) {
    if (StringUtils.isBlank(title)) {
        return ServiceVOResult.error("100005", "?");
    }
    SkillTag tag = SkillTag.getTagById(industryId);
    if (null == tag || tag.getTagType() != SkillTag.TagType.CATEGORY) {
        return ServiceVOResult.error("100005", "Id" + industryId);
    }
    if (!Pattern.matches("^\\d{0,8}(\\.\\d)?$", budget) && !"-1".equals(budget)) {
        return ServiceVOResult.error("100005", "??8?1??");
    }
    if (null != attachs && attachs.size() > 5) {
        return ServiceVOResult.error("1006", "??");
    }

    ObjectNode data = Json.newObject();
    data.put("title", title);
    data.put("info", info);
    data.put("budget", budget);
    data.put("industry", industryId);
    data.set("tags", Json.toJson(skillsTags));
    if (null != attachs) {
        ArrayNode attachsNode = Json.newObject().arrayNode();
        for (Long attachId : attachs) {
            ObjectNode attachNode = Json.newObject();
            attachNode.put("attachId", attachId);
            attachsNode.add(attachNode);
        }
        data.set("attachs", attachsNode);
    }

    ObjectNodeResult objectNodeResult = new ObjectNodeResult();
    ServiceResult createResult = createOrUpdateRequire(data, objectNodeResult);
    if (!createResult.isSuccess()) {
        return ServiceVOResult.create(createResult);
    }

    CommonVO vo = CommonVO.create();
    vo.set("requireId", objectNodeResult.getObjectNode().path("requireId").asLong(-1));

    return ServiceVOResult.success(vo);
}

From source file:models.GlobalTransPoint.java

/**
 * Converts json tree what flat rows in database
 * //from w w  w  . j  av a2  s  . c o  m
 * There are many repeated code blocks which same of the each other in this method, fix it
 * 
 */
public static String listAllAsJson() {
    String result = CacheUtils.getValue(GlobalTransPoint.class, "listAll");
    if (result != null)
        return result;

    List<GlobalTransPoint> rootList = new ArrayList<GlobalTransPoint>();
    Map<Integer, List<GlobalTransPoint>> level1Map = new LinkedHashMap<Integer, List<GlobalTransPoint>>();
    Map<Integer, List<GlobalTransPoint>> level2Map = new LinkedHashMap<Integer, List<GlobalTransPoint>>();
    Map<Integer, List<GlobalTransPoint>> level3Map = new LinkedHashMap<Integer, List<GlobalTransPoint>>();
    Map<Integer, List<GlobalTransPoint>> level4Map = new LinkedHashMap<Integer, List<GlobalTransPoint>>();
    Map<Integer, List<GlobalTransPoint>> level5Map = new LinkedHashMap<Integer, List<GlobalTransPoint>>();

    List<GlobalTransPoint> codeList = find.where().eq("workspace", CacheUtils.getWorkspaceId()).orderBy("name")
            .findList();

    for (GlobalTransPoint item : codeList) {
        if (item.par5Id != null) {
            arrangeItems(level5Map, item, item.par5Id);
        } else if (item.par5Id == null && item.par4Id != null) {
            arrangeItems(level4Map, item, item.par4Id);
        } else if (item.par4Id == null && item.par3Id != null) {
            arrangeItems(level3Map, item, item.par3Id);
        } else if (item.par3Id == null && item.par2Id != null) {
            arrangeItems(level2Map, item, item.par2Id);
        } else if (item.par2Id == null && item.par1Id != null) {
            arrangeItems(level1Map, item, item.par1Id);
        } else if (item.par1Id == null) {
            rootList.add(item);
        }
    }

    /**
     * Root level
     */
    ArrayNode rootAN = Json.newObject().arrayNode();
    for (GlobalTransPoint rootItem : rootList) {
        ObjectNode itemRL = Json.newObject();
        itemRL.put("key", rootItem.id);
        itemRL.put("title", rootItem.name);
        if (level1Map.containsKey(rootItem.id)) {
            itemRL.put("isFolder", true);

            /**
             * Level 1
             */
            ArrayNode level1AN = Json.newObject().arrayNode();
            List<GlobalTransPoint> level1List = level1Map.get(rootItem.id);
            for (GlobalTransPoint level1Item : level1List) {
                ObjectNode item1L = Json.newObject();
                item1L.put("key", level1Item.id);
                item1L.put("title", level1Item.name);
                if (level2Map.containsKey(level1Item.id)) {
                    item1L.put("isFolder", true);

                    /**
                     * Level 2
                     */
                    ArrayNode level2AN = Json.newObject().arrayNode();
                    List<GlobalTransPoint> level2List = level2Map.get(level1Item.id);
                    for (GlobalTransPoint level2Item : level2List) {
                        ObjectNode item2L = Json.newObject();
                        item2L.put("key", level2Item.id);
                        item2L.put("title", level2Item.name);
                        if (level3Map.containsKey(level2Item.id)) {
                            item2L.put("isFolder", true);

                            /**
                             * Level 3
                             */
                            ArrayNode level3AN = Json.newObject().arrayNode();
                            List<GlobalTransPoint> level3List = level3Map.get(level2Item.id);
                            for (GlobalTransPoint level3Item : level3List) {
                                ObjectNode item3L = Json.newObject();
                                item3L.put("key", level3Item.id);
                                item3L.put("title", level3Item.name);
                                if (level4Map.containsKey(level3Item.id)) {
                                    item3L.put("isFolder", true);

                                    /**
                                     * Level 4
                                     */
                                    ArrayNode level4AN = Json.newObject().arrayNode();
                                    List<GlobalTransPoint> level4List = level4Map.get(level3Item.id);
                                    for (GlobalTransPoint level4Item : level4List) {
                                        ObjectNode item4L = Json.newObject();
                                        item4L.put("key", level4Item.id);
                                        item4L.put("title", level4Item.name);
                                        if (level5Map.containsKey(level4Item.id)) {
                                            item4L.put("isFolder", true);

                                            /**
                                             * Level 5
                                             */
                                            ArrayNode level5AN = Json.newObject().arrayNode();
                                            List<GlobalTransPoint> level5List = level5Map.get(level4Item.id);
                                            for (GlobalTransPoint level5Item : level5List) {
                                                ObjectNode item5L = Json.newObject();
                                                item5L.put("key", level5Item.id);
                                                item5L.put("title", level5Item.name);
                                                level5AN.add(item5L);
                                            }
                                            item4L.put("children", level5AN);
                                        }
                                        level4AN.add(item4L);
                                    }
                                    item3L.put("children", level4AN);
                                }
                                level3AN.add(item3L);
                            }
                            item2L.put("children", level3AN);
                        }
                        level2AN.add(item2L);
                    }
                    item1L.put("children", level2AN);
                }
                level1AN.add(item1L);
            }
            itemRL.put("children", level1AN);
        }
        rootAN.add(itemRL);
    }

    result = Json.stringify(rootAN);
    CacheUtils.setValue(GlobalTransPoint.class, "listAll", result);

    return result;
}

From source file:models.GlobalPrivateCode.java

/**
 * Converts json tree what flat rows in database
 * /*  w w  w.j  a v  a  2  s. c o m*/
 * There are many repeated code blocks which same of the each other in this method, fix it
 * 
 */
public static String listAllAsJson() {
    String result = CacheUtils.getValue(GlobalPrivateCode.class, "listAll");
    if (result != null)
        return result;

    List<GlobalPrivateCode> rootList = new ArrayList<GlobalPrivateCode>();
    Map<Integer, List<GlobalPrivateCode>> level1Map = new LinkedHashMap<Integer, List<GlobalPrivateCode>>();
    Map<Integer, List<GlobalPrivateCode>> level2Map = new LinkedHashMap<Integer, List<GlobalPrivateCode>>();
    Map<Integer, List<GlobalPrivateCode>> level3Map = new LinkedHashMap<Integer, List<GlobalPrivateCode>>();
    Map<Integer, List<GlobalPrivateCode>> level4Map = new LinkedHashMap<Integer, List<GlobalPrivateCode>>();
    Map<Integer, List<GlobalPrivateCode>> level5Map = new LinkedHashMap<Integer, List<GlobalPrivateCode>>();

    List<GlobalPrivateCode> codeList = find.where().eq("workspace", CacheUtils.getWorkspaceId()).orderBy("name")
            .findList();

    for (GlobalPrivateCode item : codeList) {
        if (item.par5Id != null) {
            arrangeItems(level5Map, item, item.par5Id);
        } else if (item.par5Id == null && item.par4Id != null) {
            arrangeItems(level4Map, item, item.par4Id);
        } else if (item.par4Id == null && item.par3Id != null) {
            arrangeItems(level3Map, item, item.par3Id);
        } else if (item.par3Id == null && item.par2Id != null) {
            arrangeItems(level2Map, item, item.par2Id);
        } else if (item.par2Id == null && item.par1Id != null) {
            arrangeItems(level1Map, item, item.par1Id);
        } else if (item.par1Id == null) {
            rootList.add(item);
        }
    }

    /**
     * Root level
     */
    ArrayNode rootAN = Json.newObject().arrayNode();
    for (GlobalPrivateCode rootItem : rootList) {
        ObjectNode itemRL = Json.newObject();
        itemRL.put("key", rootItem.id);
        itemRL.put("title", rootItem.name);
        if (level1Map.containsKey(rootItem.id)) {
            itemRL.put("isFolder", true);

            /**
             * Level 1
             */
            ArrayNode level1AN = Json.newObject().arrayNode();
            List<GlobalPrivateCode> level1List = level1Map.get(rootItem.id);
            for (GlobalPrivateCode level1Item : level1List) {
                ObjectNode item1L = Json.newObject();
                item1L.put("key", level1Item.id);
                item1L.put("title", level1Item.name);
                if (level2Map.containsKey(level1Item.id)) {
                    item1L.put("isFolder", true);

                    /**
                     * Level 2
                     */
                    ArrayNode level2AN = Json.newObject().arrayNode();
                    List<GlobalPrivateCode> level2List = level2Map.get(level1Item.id);
                    for (GlobalPrivateCode level2Item : level2List) {
                        ObjectNode item2L = Json.newObject();
                        item2L.put("key", level2Item.id);
                        item2L.put("title", level2Item.name);
                        if (level3Map.containsKey(level2Item.id)) {
                            item2L.put("isFolder", true);

                            /**
                             * Level 3
                             */
                            ArrayNode level3AN = Json.newObject().arrayNode();
                            List<GlobalPrivateCode> level3List = level3Map.get(level2Item.id);
                            for (GlobalPrivateCode level3Item : level3List) {
                                ObjectNode item3L = Json.newObject();
                                item3L.put("key", level3Item.id);
                                item3L.put("title", level3Item.name);
                                if (level4Map.containsKey(level3Item.id)) {
                                    item3L.put("isFolder", true);

                                    /**
                                     * Level 4
                                     */
                                    ArrayNode level4AN = Json.newObject().arrayNode();
                                    List<GlobalPrivateCode> level4List = level4Map.get(level3Item.id);
                                    for (GlobalPrivateCode level4Item : level4List) {
                                        ObjectNode item4L = Json.newObject();
                                        item4L.put("key", level4Item.id);
                                        item4L.put("title", level4Item.name);
                                        if (level5Map.containsKey(level4Item.id)) {
                                            item4L.put("isFolder", true);

                                            /**
                                             * Level 5
                                             */
                                            ArrayNode level5AN = Json.newObject().arrayNode();
                                            List<GlobalPrivateCode> level5List = level5Map.get(level4Item.id);
                                            for (GlobalPrivateCode level5Item : level5List) {
                                                ObjectNode item5L = Json.newObject();
                                                item5L.put("key", level5Item.id);
                                                item5L.put("title", level5Item.name);
                                                level5AN.add(item5L);
                                            }
                                            item4L.put("children", level5AN);
                                        }
                                        level4AN.add(item4L);
                                    }
                                    item3L.put("children", level4AN);
                                }
                                level3AN.add(item3L);
                            }
                            item2L.put("children", level3AN);
                        }
                        level2AN.add(item2L);
                    }
                    item1L.put("children", level2AN);
                }
                level1AN.add(item1L);
            }
            itemRL.put("children", level1AN);
        }
        rootAN.add(itemRL);
    }

    result = Json.stringify(rootAN);
    CacheUtils.setValue(GlobalPrivateCode.class, "listAll", result);

    return result;
}