Example usage for com.fasterxml.jackson.databind.node JsonNodeType OBJECT

List of usage examples for com.fasterxml.jackson.databind.node JsonNodeType OBJECT

Introduction

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

Prototype

JsonNodeType OBJECT

To view the source code for com.fasterxml.jackson.databind.node JsonNodeType OBJECT.

Click Source Link

Usage

From source file:com.hp.autonomy.hod.client.api.textindex.query.parametric.GetParametricValuesServiceImpl.java

private List<FieldValues> parseResponse(final JsonNode response) {
    if (response == null || response.get("fields") == null) {
        throw new RuntimeException("Failed to parse JSON");
    }// w w w  . j  a v  a2s . c  o m

    final JsonNode fieldsNode = response.get("fields");

    if (fieldsNode.getNodeType() == JsonNodeType.OBJECT || fieldsNode.getNodeType() == JsonNodeType.ARRAY) {
        final List<FieldValues> output = new ArrayList<>();

        for (final JsonNode node : fieldsNode) {
            try {
                final FieldValues fieldValues = objectMapper.treeToValue(node, FieldValues.class);
                output.add(fieldValues);
            } catch (final JsonProcessingException e) {
                throw new RuntimeException("Failed to parse JSON", e);
            }
        }

        return output;
    } else {
        throw new RuntimeException("Failed to parse JSON");
    }
}

From source file:com.spotify.ffwd.json.JsonObjectMapperDecoder.java

private Map<String, String> decodeAttributes(JsonNode tree, String name) {
    final JsonNode n = tree.get(name);

    if (n == null)
        return EMPTY_ATTRIBUTES;

    if (n.getNodeType() != JsonNodeType.OBJECT)
        return EMPTY_ATTRIBUTES;

    final Map<String, String> attributes = Maps.newHashMap();

    final Iterator<Map.Entry<String, JsonNode>> iter = n.fields();

    while (iter.hasNext()) {
        final Map.Entry<String, JsonNode> e = iter.next();
        attributes.put(e.getKey(), e.getValue().asText());
    }//from  www  .ja v a  2 s  . c om

    return attributes;
}

From source file:de.thingweb.typesystem.jsonschema.JsonSchemaType.java

public static JsonType getJsonType(JsonNode jsonSchemaNode) throws JsonSchemaException {
    JsonType jtype = null;/* w w  w.  ja v a  2  s  . c om*/

    if (jsonSchemaNode != null) {
        JsonNode typeNode = jsonSchemaNode.findValue("type");
        if (typeNode != null) {
            switch (typeNode.asText()) {
            case "boolean":
                jtype = new JsonBoolean();
                break;
            case "integer":
            case "number":
                boolean exclusiveMinimum = false;
                JsonNode exclusiveMinimumNode = jsonSchemaNode.findValue("exclusiveMinimum");
                if (exclusiveMinimumNode != null
                        && exclusiveMinimumNode.getNodeType() == JsonNodeType.BOOLEAN) {
                    exclusiveMinimum = exclusiveMinimumNode.asBoolean();
                }
                boolean exclusiveMaximum = false;
                JsonNode exclusiveMaximumNode = jsonSchemaNode.findValue("exclusiveMaximum");
                if (exclusiveMaximumNode != null
                        && exclusiveMaximumNode.getNodeType() == JsonNodeType.BOOLEAN) {
                    exclusiveMaximum = exclusiveMaximumNode.asBoolean();
                }

                if ("integer".equals(typeNode.asText())) {
                    jtype = new JsonInteger();
                    JsonNode minimumNode = jsonSchemaNode.findValue("minimum");
                    if (minimumNode != null && minimumNode.getNodeType() == JsonNodeType.NUMBER) {
                        ((JsonInteger) jtype).setMinimum(minimumNode.asLong());
                    }
                    JsonNode maximumNode = jsonSchemaNode.findValue("maximum");
                    if (maximumNode != null && maximumNode.getNodeType() == JsonNodeType.NUMBER) {
                        ((JsonInteger) jtype).setMaximum(maximumNode.asLong());
                    }
                } else {
                    assert ("number".equals(typeNode.asText()));

                    jtype = new JsonNumber();
                    JsonNode minimumNode = jsonSchemaNode.findValue("minimum");
                    if (minimumNode != null && minimumNode.getNodeType() == JsonNodeType.NUMBER) {
                        ((JsonNumber) jtype).setMinimum(minimumNode.asDouble());
                    }
                    JsonNode maximumNode = jsonSchemaNode.findValue("maximum");
                    if (maximumNode != null && maximumNode.getNodeType() == JsonNodeType.NUMBER) {
                        ((JsonNumber) jtype).setMaximum(maximumNode.asDouble());
                    }
                }

                ((AbstractJsonNumeric) jtype).setExclusiveMinimum(exclusiveMinimum);
                ((AbstractJsonNumeric) jtype).setExclusiveMaximum(exclusiveMaximum);

                break;
            case "null":
                jtype = new JsonNull();
                break;
            case "string":
                jtype = new JsonString();
                break;
            case "array":
                JsonNode itemsNode = jsonSchemaNode.findValue("items");
                if (itemsNode != null && JsonNodeType.OBJECT == itemsNode.getNodeType()) {
                    jtype = new JsonArray(getJsonType(itemsNode));
                } else {
                    throw new JsonSchemaException("items not object");
                }

                break;
            case "object":
                JsonNode propertiesNode = jsonSchemaNode.findValue("properties");
                if (propertiesNode != null && JsonNodeType.OBJECT == propertiesNode.getNodeType()) {
                    Iterator<Entry<String, JsonNode>> iter = propertiesNode.fields();
                    Map<String, JsonType> properties = new HashMap<String, JsonType>();
                    while (iter.hasNext()) {
                        Entry<String, JsonNode> e = iter.next();
                        JsonNode nodeProp = e.getValue();
                        properties.put(e.getKey(), getJsonType(nodeProp));
                    }
                    jtype = new JsonObject(properties);
                } else {
                    throw new JsonSchemaException("Properties not object");
                }
                // required
                JsonNode requiredNode = jsonSchemaNode.findValue("required");
                if (requiredNode != null && JsonNodeType.ARRAY == requiredNode.getNodeType()) {
                    ArrayNode an = (ArrayNode) requiredNode;
                    Iterator<JsonNode> iterReq = an.elements();
                    while (iterReq.hasNext()) {
                        JsonNode nreq = iterReq.next();
                        if (JsonNodeType.STRING == nreq.getNodeType()) {
                            ((JsonObject) jtype).addRequired(nreq.asText());
                        } else {
                            throw new JsonSchemaException("Unexpected required node: " + nreq);
                        }
                    }
                }
                break;
            }
        }
    }

    return jtype;
}

From source file:de.hbz.lobid.helper.CompareJsonMaps.java

/**
 * Construct a map with json paths as keys with aggregated values form json
 * nodes./*w w w  .ja  v a  2  s.  c  o  m*/
 * 
 * @param jnode the JsonNode which should be transformed into a map
 * @param map the map constructed out of the JsonNode
 */
public void extractFlatMapFromJsonNode(final JsonNode jnode, final HashMap<String, String> map) {
    if (jnode.getNodeType().equals(JsonNodeType.OBJECT)) {
        final Iterator<Map.Entry<String, JsonNode>> it = jnode.fields();
        while (it.hasNext()) {
            final Map.Entry<String, JsonNode> entry = it.next();
            stack.push(entry.getKey());
            extractFlatMapFromJsonNode(entry.getValue(), map);
            stack.pop();
        }
    } else if (jnode.isArray()) {
        final Iterator<JsonNode> it = jnode.iterator();
        while (it.hasNext()) {
            extractFlatMapFromJsonNode(it.next(), map);
        }
    } else if (jnode.isValueNode()) {
        String value = jnode.toString();
        if (map.containsKey(stack.toString()))
            value = map.get(stack.toString()).concat("," + jnode.toString());
        map.put(stack.toString(), value);
        CompareJsonMaps.logger.trace("Stored this path as key into map:" + stack.toString(), value);
    }
}

From source file:io.swagger.parser.util.SwaggerDeserializer.java

public Swagger parseRoot(JsonNode node, ParseResult result) {
    String location = "";
    Swagger swagger = new Swagger();
    if (node.getNodeType().equals(JsonNodeType.OBJECT)) {
        ObjectNode on = (ObjectNode) node;
        Iterator<JsonNode> it = null;

        // required
        String value = getString("swagger", on, true, location, result);
        swagger.setSwagger(value);/*from w ww.  ja  v a2s  .  c  om*/

        ObjectNode obj = getObject("info", on, true, "", result);
        if (obj != null) {
            Info info = info(obj, "info", result);
            swagger.info(info);
        }

        // optional
        value = getString("host", on, false, location, result);
        swagger.setHost(value);

        value = getString("basePath", on, false, location, result);
        swagger.setBasePath(value);

        ArrayNode array = getArray("schemes", on, false, location, result);
        if (array != null) {
            it = array.iterator();
            while (it.hasNext()) {
                JsonNode n = it.next();
                String s = getString(n, location + ".schemes", result);
                if (s != null) {
                    Scheme scheme = Scheme.forValue(s);
                    if (scheme != null) {
                        swagger.scheme(scheme);
                    }
                }
            }
        }

        array = getArray("consumes", on, false, location, result);
        if (array != null) {
            it = array.iterator();
            while (it.hasNext()) {
                JsonNode n = it.next();
                String s = getString(n, location + ".consumes", result);
                if (s != null) {
                    swagger.consumes(s);
                }
            }
        }

        array = getArray("produces", on, false, location, result);
        if (array != null) {
            it = array.iterator();
            while (it.hasNext()) {
                JsonNode n = it.next();
                String s = getString(n, location + ".produces", result);
                if (s != null) {
                    swagger.produces(s);
                }
            }
        }

        obj = getObject("paths", on, true, location, result);
        Map<String, Path> paths = paths(obj, "paths", result);
        swagger.paths(paths);

        obj = getObject("definitions", on, false, location, result);
        Map<String, Model> definitions = definitions(obj, "definitions", result);
        swagger.setDefinitions(definitions);

        obj = getObject("parameters", on, false, location, result);
        // TODO: parse
        Map<String, Parameter> parameters = Json.mapper().convertValue(obj,
                Json.mapper().getTypeFactory().constructMapType(Map.class, String.class, Parameter.class));
        swagger.setParameters(parameters);

        obj = getObject("responses", on, false, location, result);
        Map<String, Response> responses = responses(obj, "responses", result);
        swagger.responses(responses);

        obj = getObject("securityDefinitions", on, false, location, result);
        Map<String, SecuritySchemeDefinition> securityDefinitions = securityDefinitions(obj, location, result);
        swagger.setSecurityDefinitions(securityDefinitions);

        array = getArray("security", on, false, location, result);
        List<SecurityRequirement> security = securityRequirements(array, location, result);
        swagger.setSecurity(security);

        array = getArray("tags", on, false, location, result);
        List<Tag> tags = tags(array, location, result);
        swagger.tags(tags);

        obj = getObject("externalDocs", on, false, location, result);
        ExternalDocs docs = externalDocs(obj, location, result);
        swagger.externalDocs(docs);

        // extra keys
        Set<String> keys = getKeys(on);
        for (String key : keys) {
            if (key.startsWith("x-")) {
                swagger.vendorExtension(key, extension(on.get(key)));
            } else if (!ROOT_KEYS.contains(key)) {
                result.extra(location, key, node.get(key));
            }
        }
    }
    return swagger;
}

From source file:com.github.arven.rest.schema.WebServiceTests.java

@Test
public void basicTestFromFile() throws Exception {
    JsonNode node = mapper.readTree(/*  ww w.  j a  v  a 2 s. co  m*/
            new URL("file:///C:/Users/brian.becker/Git/java-rest-schema/target/test-classes/fstab.json"));
    Assert.assertTrue(node.getNodeType() == JsonNodeType.OBJECT);
    Assert.assertTrue(node.path("/tmp").path("storage").path("sizeInMB").isNumber());
    Assert.assertEquals(node.path("/tmp").path("storage").path("sizeInMB").asLong(), 64);

    Assert.assertTrue(node.path("/var/www").path("storage").path("server").isValueNode());
    Assert.assertEquals(node.path("/var/www").path("storage").path("server").asText(), "my.nfs.server");
}

From source file:org.agatom.springatom.cmp.action.DefaultActionsModelReader.java

private ActionRole resolveSecurityRoles(final JsonNode roles, final ActionRoleMap.Connector[] connectors) {
    if (JsonNodeType.STRING.equals(roles.getNodeType())) {
        return new DefaultActionRole().appendRole(roles.asText());
    }//from   www  .j  a  v  a 2  s .  c o  m
    final Iterator<JsonNode> iterator = roles.iterator();
    ActionRole actionRole = null;

    while (iterator.hasNext()) {
        final JsonNode node = iterator.next();
        final JsonNodeType type = node.getNodeType();
        if (JsonNodeType.STRING.equals(type)) {
            actionRole = new DefaultActionRole().appendRole(node.asText());
        } else if (JsonNodeType.ARRAY.equals(type)) {

            final ArrayNode arrayNode = (ArrayNode) node;
            final DefaultActionRole role = new DefaultActionRole();
            for (JsonNode textRoleNode : arrayNode) {
                role.appendRole(textRoleNode.asText());
            }
            actionRole = role;

        } else if (JsonNodeType.OBJECT.equals(type)) {

            final ActionRoleMap actionRoleMap = new ActionRoleMap();
            final Map<ActionRoleMap.Connector, DefaultActionRole> map = Maps
                    .newHashMapWithExpectedSize(node.size());
            String strConnector;
            for (final ActionRoleMap.Connector connector : connectors) {
                strConnector = connector.toString().toLowerCase();
                if (node.has(strConnector)) {
                    final DefaultActionRole role = new DefaultActionRole();
                    for (JsonNode textRoleNode : node.get(strConnector)) {
                        role.appendRole(textRoleNode.asText());
                    }
                    map.put(connector, role);
                }
            }
            actionRoleMap.setRoles(map);
            actionRole = actionRoleMap;

        }
    }

    return actionRole;
}

From source file:io.swagger.parser.util.SwaggerDeserializer.java

public Map<String, Path> paths(ObjectNode obj, String location, ParseResult result) {
    Map<String, Path> output = new LinkedHashMap<>();
    if (obj == null) {
        return null;
    }// w w  w . j a  v a2  s . co  m

    Set<String> pathKeys = getKeys(obj);
    for (String pathName : pathKeys) {
        JsonNode pathValue = obj.get(pathName);
        if (!pathValue.getNodeType().equals(JsonNodeType.OBJECT)) {
            result.invalidType(location, pathName, "object", pathValue);
        } else {
            ObjectNode path = (ObjectNode) pathValue;
            Path pathObj = path(path, location + ".'" + pathName + "'", result);
            output.put(pathName, pathObj);
        }
    }
    return output;
}

From source file:io.swagger.v3.parser.util.OpenAPIDeserializer.java

public OpenAPI parseRoot(JsonNode node, ParseResult result, String path) {
    String location = "";
    OpenAPI openAPI = new OpenAPI();
    if (node.getNodeType().equals(JsonNodeType.OBJECT)) {
        ObjectNode rootNode = (ObjectNode) node;

        // required
        String value = getString("openapi", rootNode, true, location, result);

        // we don't even try if the version isn't there
        if (value == null || !value.startsWith("3.0")) {
            return null;
        }/*w  w w  .ja  v  a 2s .  co m*/
        openAPI.setOpenapi(value);

        ObjectNode obj = getObject("info", rootNode, true, location, result);
        if (obj != null) {
            Info info = getInfo(obj, "info", result);
            openAPI.setInfo(info);
        }

        obj = getObject("paths", rootNode, true, location, result);
        if (obj != null) {
            Paths paths = getPaths(obj, "paths", result);
            openAPI.setPaths(paths);
        }

        obj = getObject("components", rootNode, false, location, result);
        if (obj != null) {
            Components components = getComponents(obj, "components", result);
            openAPI.setComponents(components);
        }

        ArrayNode array = getArray("servers", rootNode, false, location, result);
        if (array != null && array.size() > 0) {
            openAPI.setServers(
                    getServersList(array, String.format("%s.%s", location, "servers"), result, path));
        } else {
            Server defaultServer = new Server();
            defaultServer.setUrl("/");
            List<Server> servers = new ArrayList<>();
            servers.add(defaultServer);
            openAPI.setServers(servers);
        }

        obj = getObject("externalDocs", rootNode, false, location, result);
        if (obj != null) {
            ExternalDocumentation externalDocs = getExternalDocs(obj, "externalDocs", result);
            openAPI.setExternalDocs(externalDocs);
        }

        array = getArray("tags", rootNode, false, location, result);
        if (array != null && array.size() > 0) {
            openAPI.setTags(getTagList(array, "tags", result));
        }

        array = getArray("security", rootNode, false, location, result);
        if (array != null && array.size() > 0) {
            List<SecurityRequirement> securityRequirements = getSecurityRequirementsList(array, "security",
                    result);
            if (securityRequirements != null && securityRequirements.size() > 0) {
                openAPI.setSecurity(securityRequirements);
            }
        }

        Map<String, Object> extensions = getExtensions(rootNode);
        if (extensions != null && extensions.size() > 0) {
            openAPI.setExtensions(extensions);
        }

        Set<String> keys = getKeys(rootNode);
        for (String key : keys) {
            if (!ROOT_KEYS.contains(key) && !key.startsWith("x-")) {
                result.extra(location, key, node.get(key));
            }
        }

    } else {
        result.invalidType(location, "openapi", "object", node);
        result.invalid();
        return null;
    }

    return openAPI;
}

From source file:io.swagger.parser.util.SwaggerDeserializer.java

public Path path(ObjectNode obj, String location, ParseResult result) {
    boolean hasRef = false;
    Path output = null;//  www.  j a  va  2s .  c o m
    if (obj.get("$ref") != null) {
        JsonNode ref = obj.get("$ref");
        if (ref.getNodeType().equals(JsonNodeType.STRING)) {
            return pathRef((TextNode) ref, location, result);
        }

        else if (ref.getNodeType().equals(JsonNodeType.OBJECT)) {
            ObjectNode on = (ObjectNode) ref;

            // extra keys
            Set<String> keys = getKeys(on);
            for (String key : keys) {
                result.extra(location, key, on.get(key));
            }
        }
        return null;
    }
    Path path = new Path();

    ArrayNode parameters = getArray("parameters", obj, false, location, result);
    path.setParameters(parameters(parameters, location, result));

    ObjectNode on = getObject("get", obj, false, location, result);
    if (on != null) {
        Operation op = operation(on, location + "(get)", result);
        if (op != null) {
            path.setGet(op);
        }
    }
    on = getObject("put", obj, false, location, result);
    if (on != null) {
        Operation op = operation(on, location + "(put)", result);
        if (op != null) {
            path.setPut(op);
        }
    }
    on = getObject("post", obj, false, location, result);
    if (on != null) {
        Operation op = operation(on, location + "(post)", result);
        if (op != null) {
            path.setPost(op);
        }
    }
    on = getObject("head", obj, false, location, result);
    if (on != null) {
        Operation op = operation(on, location + "(head)", result);
        if (op != null) {
            path.setHead(op);
        }
    }
    on = getObject("delete", obj, false, location, result);
    if (on != null) {
        Operation op = operation(on, location + "(delete)", result);
        if (op != null) {
            path.setDelete(op);
        }
    }
    on = getObject("patch", obj, false, location, result);
    if (on != null) {
        Operation op = operation(on, location + "(patch)", result);
        if (op != null) {
            path.setPatch(op);
        }
    }
    on = getObject("options", obj, false, location, result);
    if (on != null) {
        Operation op = operation(on, location + "(options)", result);
        if (op != null) {
            path.setOptions(op);
        }
    }

    // extra keys
    Set<String> keys = getKeys(obj);
    for (String key : keys) {
        if (key.startsWith("x-")) {
            path.setVendorExtension(key, extension(obj.get(key)));
        } else if (!PATH_KEYS.contains(key)) {
            result.extra(location, key, obj.get(key));
        }
    }
    return path;
}