Example usage for com.fasterxml.jackson.databind.node JsonNodeFactory objectNode

List of usage examples for com.fasterxml.jackson.databind.node JsonNodeFactory objectNode

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.databind.node.*
  5. JsonNodeFactory
  6. objectNode

Introduction

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

Prototype

public ObjectNode objectNode()

Source Link

Usage

From source file:org.teavm.flavour.json.test.TeaVMJSONRunner.java

public static final JsonNode convert(JsonNodeFactory nf, Node node) {
    if (node.isNull()) {
        return nf.nullNode();
    } else if (node.isBoolean()) {
        BooleanNode booleanNode = (BooleanNode) node;
        return nf.booleanNode(booleanNode.getValue());
    } else if (node.isNumber()) {
        NumberNode numberNode = (NumberNode) node;
        if (numberNode.isInt()) {
            return nf.numberNode(numberNode.getIntValue());
        } else {//  www  .  j  a  va 2  s.  co m
            return nf.numberNode(numberNode.getValue());
        }
    } else if (node.isString()) {
        StringNode stringNode = (StringNode) node;
        return nf.textNode(stringNode.getValue());
    } else if (node.isArray()) {
        ArrayNode result = nf.arrayNode();
        org.teavm.flavour.json.tree.ArrayNode source = (org.teavm.flavour.json.tree.ArrayNode) node;
        for (int i = 0; i < source.size(); ++i) {
            result.add(convert(nf, source.get(i)));
        }
        return result;
    } else if (node.isObject()) {
        com.fasterxml.jackson.databind.node.ObjectNode result = nf.objectNode();
        ObjectNode objectNode = (ObjectNode) node;
        for (String key : objectNode.allKeys()) {
            result.replace(key, convert(nf, objectNode.get(key)));
        }
        return result;
    } else {
        throw new IllegalArgumentException("Can't convert this JSON node");
    }
}

From source file:edumsg.core.commands.tweet.UnRetweetCommand.java

@Override
public void execute() {
    try {/*from w  ww .  j a  va 2s  .  c o m*/
        dbConn = PostgresConnection.getDataSource().getConnection();
        dbConn.setAutoCommit(true);
        proc = dbConn.prepareCall("{? = call unretweet(?,?)}");
        proc.setPoolable(true);
        proc.registerOutParameter(1, Types.INTEGER);
        proc.setInt(2, Integer.parseInt(map.get("tweet_id")));
        proc.setString(3, map.get("session_id"));
        proc.execute();

        int retweets = proc.getInt(1);

        MyObjectMapper mapper = new MyObjectMapper();
        JsonNodeFactory nf = JsonNodeFactory.instance;
        ObjectNode root = nf.objectNode();
        root.put("app", map.get("app"));
        root.put("method", map.get("method"));
        root.put("status", "ok");
        root.put("code", "200");
        root.put("favorites", retweets);
        try {
            CommandsHelp.submit(map.get("app"), mapper.writeValueAsString(root), map.get("correlation_id"),
                    LOGGER);
            String cacheEntry = UserCache.userCache.get("user_tweets:" + map.get("session_id"));
            if (cacheEntry != null) {
                JSONObject cacheEntryJson = new JSONObject(cacheEntry);
                cacheEntryJson.put("cacheStatus", "invalid");
                //                    System.out.println("invalidated");
                UserCache.userCache.set("user_tweets:" + map.get("session_id"), cacheEntryJson.toString());
            }
            String cacheEntry1 = UserCache.userCache.get("timeline:" + map.get("session_id"));
            if (cacheEntry1 != null) {
                JSONObject cacheEntryJson = new JSONObject(cacheEntry1);
                cacheEntryJson.put("cacheStatus", "invalid");
                //                    System.out.println("invalidated");
                UserCache.userCache.set("timeline:" + map.get("session_id"), cacheEntryJson.toString());
            }
            String cacheEntry2 = TweetsCache.tweetCache.get("get_earliest_replies:" + map.get("session_id"));
            if (cacheEntry2 != null) {
                JSONObject cacheEntryJson = new JSONObject(cacheEntry2);
                cacheEntryJson.put("cacheStatus", "invalid");
                //                    System.out.println("invalidated");
                TweetsCache.tweetCache.set("get_earliest_replies:" + map.get("session_id"),
                        cacheEntryJson.toString());
            }
            String cacheEntry3 = TweetsCache.tweetCache.get("get_replies:" + map.get("session_id"));
            if (cacheEntry3 != null) {
                JSONObject cacheEntryJson = new JSONObject(cacheEntry3);
                cacheEntryJson.put("cacheStatus", "invalid");
                //                    System.out.println("invalidated");
                TweetsCache.tweetCache.set("get_replies:" + map.get("session_id"), cacheEntryJson.toString());
            }
            String cacheEntry4 = ListCache.listCache.get("get_list_feeds:" + map.get("session_id"));
            if (cacheEntry4 != null) {
                JSONObject cacheEntryJson = new JSONObject(cacheEntry4);
                cacheEntryJson.put("cacheStatus", "invalid");
                //                    System.out.println("invalidated");
                ListCache.listCache.set("get_list_feeds:" + map.get("session_id"), cacheEntryJson.toString());
            }
        } catch (JsonGenerationException e) {
            LOGGER.log(Level.SEVERE, e.getMessage(), e);
        } catch (JsonMappingException e) {
            LOGGER.log(Level.SEVERE, e.getMessage(), e);
        } catch (IOException e) {
            LOGGER.log(Level.SEVERE, e.getMessage(), e);
        }
        //            catch (JSONException e) {
        //                e.printStackTrace();
        //            }

    } catch (PSQLException e) {
        CommandsHelp.handleError(map.get("app"), map.get("method"), e.getMessage(), map.get("correlation_id"),
                LOGGER);
        LOGGER.log(Level.SEVERE, e.getMessage(), e);
    } catch (SQLException e) {
        CommandsHelp.handleError(map.get("app"), map.get("method"), e.getMessage(), map.get("correlation_id"),
                LOGGER);
        LOGGER.log(Level.SEVERE, e.getMessage(), e);
    } finally {
        PostgresConnection.disconnect(null, proc, dbConn);
    }
}

From source file:net.mostlyharmless.jghservice.connector.jira.UpdateVersionsOnIssue.java

@Override
public String getJson() throws JsonProcessingException {
    JsonNodeFactory factory = JsonNodeFactory.instance;
    ObjectNode root = factory.objectNode();
    ObjectNode update = factory.objectNode();
    root.put("update", update);

    if (!fixVersionsAdded.isEmpty() || !fixVersionsRemoved.isEmpty()) {
        ArrayNode fixVersions = factory.arrayNode();
        for (String version : fixVersionsAdded) {
            ObjectNode add = factory.objectNode();
            ObjectNode addVersion = factory.objectNode();
            addVersion.put("name", version);
            add.put("add", addVersion);
            fixVersions.add(add);//from w w  w. java 2 s  .  com
        }

        for (String version : fixVersionsRemoved) {
            ObjectNode remove = factory.objectNode();
            ObjectNode removeVersion = factory.objectNode();
            removeVersion.put("name", version);
            remove.put("remove", removeVersion);
            fixVersions.add(remove);
        }

        update.put("fixVersions", fixVersions);
    }

    if (!affectsVersionsAdded.isEmpty() || !affectsVersionsRemoved.isEmpty()) {
        ArrayNode affectsVersions = factory.arrayNode();
        for (String version : affectsVersionsAdded) {
            ObjectNode add = factory.objectNode();
            ObjectNode addVersion = factory.objectNode();
            addVersion.put("name", version);
            add.put("add", addVersion);
            affectsVersions.add(add);
        }

        for (String version : affectsVersionsRemoved) {
            ObjectNode remove = factory.objectNode();
            ObjectNode removeVersion = factory.objectNode();
            removeVersion.put("name", version);
            remove.put("remove", removeVersion);
            affectsVersions.add(remove);
        }

        update.put("versions", affectsVersions);
    }

    return new ObjectMapper().writeValueAsString(root);

}

From source file:uk.ac.ebi.eva.server.ws.ArchiveWSServer.java

@RequestMapping(value = "/studies/stats", method = RequestMethod.GET)
public QueryResponse getStudiesStats(@RequestParam(name = "species", required = false) List<String> species,
        @RequestParam(name = "type", required = false) List<String> types,
        @RequestParam(name = "structural", defaultValue = "false") boolean structural) {
    initializeQueryOptions();/*from  w  w w .  j  ava2  s.c o  m*/
    if (species != null && !species.isEmpty()) {
        queryOptions.put("species", species);
    }
    if (types != null && !types.isEmpty()) {
        queryOptions.put("type", types);
    }

    QueryResult<Map.Entry<String, Integer>> resultSpecies, resultTypes;

    if (structural) {
        resultSpecies = archiveDgvaDbAdaptor.countStudiesPerSpecies(queryOptions);
        resultTypes = archiveDgvaDbAdaptor.countStudiesPerType(queryOptions);
    } else {
        resultSpecies = archiveEvaproDbAdaptor.countStudiesPerSpecies(queryOptions);
        resultTypes = archiveEvaproDbAdaptor.countStudiesPerType(queryOptions);
    }

    QueryResult combinedQueryResult = new QueryResult();
    combinedQueryResult.setDbTime(resultSpecies.getDbTime() + resultTypes.getDbTime());

    JsonNodeFactory factory = new JsonNodeFactory(true);
    ObjectNode root = factory.objectNode();
    combinedQueryResult.addResult(root);
    combinedQueryResult.setNumTotalResults(combinedQueryResult.getNumResults());

    // Species
    ObjectNode speciesNode = factory.objectNode();
    for (Map.Entry<String, Integer> speciesCount : resultSpecies.getResult()) {
        speciesNode.put(speciesCount.getKey(), speciesCount.getValue());
    }
    root.put("species", speciesNode);

    // Types
    ObjectNode typesNode = factory.objectNode();
    for (Map.Entry<String, Integer> typesCount : resultTypes.getResult()) {
        typesNode.put(typesCount.getKey(), typesCount.getValue());
    }
    root.put("type", typesNode);

    return setQueryResponse(combinedQueryResult);
}

From source file:com.redhat.lightblue.metadata.PredefinedFieldsTest.java

@Test
public void testDocModify() throws Exception {
    JsonNodeFactory factory = JsonNodeFactory.withExactBigDecimals(false);
    ObjectNode node = factory.objectNode();
    JsonDoc doc = new JsonDoc(node);
    node.put("fld1", "value").put("arr#", 1);
    node.set("arr", factory.arrayNode().add(1).add(2));
    node.set("arr2", factory.arrayNode().add(1).add(2).add(3));
    ObjectNode obj = factory.objectNode();
    obj.put("fld3", "val");
    obj.set("arr3", factory.arrayNode().add(1).add(2).add(3).add(4));
    node.set("obj", obj);

    PredefinedFields.updateArraySizes(factory, node);

    Assert.assertEquals(2, doc.get(new Path("arr#")).intValue());
    Assert.assertEquals(3, doc.get(new Path("arr2#")).intValue());
    Assert.assertEquals(4, doc.get(new Path("obj.arr3#")).intValue());
}

From source file:io.fabric8.kubernetes.api.KubernetesHelper.java

protected static JsonNode findOrCreateConfig(Object[] objects) {
    for (Object object : objects) {
        if (object instanceof JsonNode) {
            JsonNode jsonNode = (JsonNode) object;
            JsonNode items = jsonNode.get("items");
            if (items != null && items.isArray()) {
                return jsonNode;
            }/*from   w  ww . j a v a  2  s  .  c  o m*/
        }
    }

    // lets create a new list
    JsonNodeFactory factory = createNodeFactory();
    ObjectNode config = factory.objectNode();
    config.set("apiVersion", factory.textNode("v1beta2"));
    config.set("kind", factory.textNode("List"));
    config.set("items", factory.arrayNode());
    return config;
}

From source file:com.redhat.lightblue.config.rdbms.RDBMSDataSourceMap.java

@Override
public String toString() {
    JsonNodeFactory jsonNodeFactory = JsonNodeFactory.withExactBigDecimals(true);

    ObjectNode root = jsonNodeFactory.objectNode();
    ObjectNode datasourcesNode = jsonNodeFactory.objectNode();
    ObjectNode databasesNode = jsonNodeFactory.objectNode();
    ObjectNode dbMapNode = jsonNodeFactory.objectNode();
    ObjectNode dsMapNode = jsonNodeFactory.objectNode();

    root.set("datasources", datasourcesNode);
    root.set("databases", databasesNode);
    root.set("dbMap", dbMapNode);
    root.set("dsMap", dsMapNode);

    if (datasources != null) {
        for (Map.Entry<String, RDBMSDataSourceConfiguration> a : datasources.entrySet()) {
            datasourcesNode.set(a.getKey(), jsonNodeFactory.textNode(a.getValue().toString()));
        }//from  w  ww.  ja va2 s .  co m
    }

    if (databases != null) {
        for (Map.Entry<String, RDBMSDataSourceConfiguration> a : databases.entrySet()) {
            databasesNode.set(a.getKey(), jsonNodeFactory.textNode(a.getValue().toString()));
        }
    }

    if (dbMap != null) {
        for (Map.Entry<String, DataSource> a : dbMap.entrySet()) {
            dbMapNode.set(a.getKey(), jsonNodeFactory.textNode(a.getValue().toString()));
        }
    }

    if (dsMap != null) {
        for (Map.Entry<String, DataSource> a : dsMap.entrySet()) {
            dsMapNode.set(a.getKey(), jsonNodeFactory.textNode(a.getValue().toString()));
        }
    }

    return JsonUtils.prettyPrint(root);
}

From source file:com.mapr.synth.samplers.FileSampler.java

private void readDelimitedData(String lookup, List<String> lines) {
    Splitter splitter;/*from   w  ww  .  j  av  a  2 s  .co m*/
    if (lookup.matches(".*\\.csv")) {
        splitter = Splitter.on(",");
    } else if (lookup.matches(".*\\.tsv")) {
        splitter = Splitter.on("\t");
    } else {
        throw new IllegalArgumentException("Must have file with .csv, .tsv or .json suffix");
    }

    List<String> names = Lists.newArrayList(splitter.split(lines.get(0)));
    JsonNodeFactory nf = JsonNodeFactory.withExactBigDecimals(false);
    ArrayNode localData = nf.arrayNode();
    for (String line : lines.subList(1, lines.size())) {
        ObjectNode r = nf.objectNode();
        List<String> fields = Lists.newArrayList(splitter.split(line));
        Preconditions.checkState(names.size() == fields.size(), "Wrong number of fields, expected ",
                names.size(), fields.size());
        Iterator<String> ix = names.iterator();
        for (String field : fields) {
            r.put(ix.next(), field);
        }
        localData.add(r);
    }
    data = localData;
}

From source file:org.lenskit.data.dao.file.JSONEntityFormat.java

@Override
public ObjectNode toJSON() {
    JsonNodeFactory nf = JsonNodeFactory.instance;

    ObjectNode json = nf.objectNode();
    json.put("format", "json");
    json.put("entity_type", entityType.getName());

    if (!attributes.isEmpty()) {
        ObjectNode attrNode = json.putObject("attributes");
        for (Map.Entry<String, TypedName<?>> attr : attributes.entrySet()) {
            ObjectNode an = attrNode.putObject(attr.getKey());
            an.put("name", attr.getValue().getName());
            an.put("type", TypeUtils.makeTypeName(attr.getValue().getType()));
        }/*w w w .jav a 2  s .co  m*/
    }

    return json;
}

From source file:org.springframework.data.rest.webmvc.json.patch.JsonPatchPatchConverter.java

/**
 * Renders a {@link Patch} as a {@link JsonNode}.
 * /*from   w w w  .  ja v  a2 s. c  o  m*/
 * @param patch the patch
 * @return a {@link JsonNode} containing JSON Patch.
 */
public JsonNode convert(Patch patch) {

    List<PatchOperation> operations = patch.getOperations();
    JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
    ArrayNode patchNode = nodeFactory.arrayNode();
    for (PatchOperation operation : operations) {
        ObjectNode opNode = nodeFactory.objectNode();
        opNode.set("op", nodeFactory.textNode(operation.getOp()));
        opNode.set("path", nodeFactory.textNode(operation.getPath()));
        if (operation instanceof FromOperation) {
            FromOperation fromOp = (FromOperation) operation;
            opNode.set("from", nodeFactory.textNode(fromOp.getFrom()));
        }
        Object value = operation.getValue();
        if (value != null) {
            opNode.set("value", MAPPER.valueToTree(value));
        }
        patchNode.add(opNode);
    }

    return patchNode;
}