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

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

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.databind.node.*
  5. JsonNodeType
  6. STRING

Introduction

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

Prototype

JsonNodeType STRING

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

Click Source Link

Usage

From source file:de.thingweb.client.security.Security4NicePlugfest.java

public String requestASToken(Registration registration, String[] adds) throws IOException {
    String asToken = null;/* w  ww.  j a va  2 s  .c  o m*/

    // Token Acquisition
    // Create a HTTP request as in the following prototype and send
    // it via TLS to the AM
    //
    // Token Acquisition
    // Create a HTTP request as in the following prototype and send
    // it via TLS to the AM
    // Request
    // POST /iam-services/0.1/oidc/am/token HTTP/1.1
    URL urlTokenAcquisition = new URL(HTTPS_PREFIX + HOST + REQUEST_TOKEN_AQUISITION);

    HttpsURLConnection httpConTokenAcquisition = (HttpsURLConnection) urlTokenAcquisition.openConnection();
    httpConTokenAcquisition.setDoOutput(true);
    httpConTokenAcquisition.setRequestProperty("Host", REQUEST_HEADER_HOST);
    httpConTokenAcquisition.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
    httpConTokenAcquisition.setRequestProperty("Accept", "application/json");
    // httpConTokenAcquisition.setRequestProperty("Authorization",
    // "Basic Base64(<c_id>:<c_secret>");
    String auth = registration.c_id + ":" + registration.c_secret;
    String authb = "Basic " + new String(Base64.getEncoder().encode(auth.getBytes()));
    httpConTokenAcquisition.setRequestProperty("Authorization", authb);
    httpConTokenAcquisition.setRequestMethod("POST");

    String requestBodyTokenAcquisition = "grant_type=client_credentials";
    if (adds == null || adds.length == 0) {
        // no additions
    } else {
        if (adds.length % 2 == 0) {
            for (int i = 0; i < (adds.length - 1); i += 2) {
                requestBodyTokenAcquisition += "&";
                requestBodyTokenAcquisition += URLEncoder.encode(adds[i], "UTF-8");
                requestBodyTokenAcquisition += "=";
                requestBodyTokenAcquisition += URLEncoder.encode(adds[i + 1], "UTF-8");
            }
        } else {
            log.warn(
                    "Additional information for token not used! Not a multiple of 2: " + Arrays.toString(adds));
        }
    }

    OutputStream outTokenAcquisition = httpConTokenAcquisition.getOutputStream();
    outTokenAcquisition.write(requestBodyTokenAcquisition.getBytes());
    outTokenAcquisition.close();

    int responseCodeoutTokenAcquisition = httpConTokenAcquisition.getResponseCode();
    log.info("responseCode TokenAcquisition for " + urlTokenAcquisition + ": "
            + responseCodeoutTokenAcquisition);

    if (responseCodeoutTokenAcquisition == 200) {
        // everything ok
        InputStream isTA = httpConTokenAcquisition.getInputStream();
        byte[] bisTA = getBytesFromInputStream(isTA);
        String jsonResponseTA = new String(bisTA);
        log.info(jsonResponseTA);

        ObjectMapper mapper = new ObjectMapper();
        JsonFactory factory = mapper.getFactory();
        JsonParser jp = factory.createParser(bisTA);
        JsonNode actualObj = mapper.readTree(jp);

        JsonNode access_token = actualObj.get("access_token");
        if (access_token == null || access_token.getNodeType() != JsonNodeType.STRING) {
            log.error("access_token: " + access_token);
        } else {
            // ok so far
            // access_token provides a JWT structure
            // see Understanding JWT
            // https://developer.atlassian.com/static/connect/docs/latest/concepts/understanding-jwt.html

            log.info("access_token: " + access_token);
            // http://jwt.io/

            // TODO verify signature (e.g., use Jose4J)

            // Note: currently we assume signature is fine.. we just fetch
            // "as_token"
            String[] decAT = access_token.textValue().split("\\.");
            if (decAT == null || decAT.length != 3) {
                log.error("Cannot build JWT tripple structure for " + access_token);
            } else {
                assert (decAT.length == 3);
                // JWT structure
                // decAT[0]; // header
                // decAT[1]; // payload
                // decAT[2]; // signature
                String decAT1 = new String(Base64.getDecoder().decode(decAT[1]));
                JsonParser jpas = factory.createParser(decAT1);
                JsonNode payload = mapper.readTree(jpas);
                JsonNode as_token = payload.get("as_token");
                if (as_token == null || as_token.getNodeType() != JsonNodeType.STRING) {
                    log.error("as_token: " + as_token);
                } else {
                    log.info("as_token: " + as_token);
                    asToken = as_token.textValue();
                }
            }
        }

    } else {
        // error
        InputStream error = httpConTokenAcquisition.getErrorStream();
        byte[] berror = getBytesFromInputStream(error);
        log.error(new String(berror));
    }

    httpConTokenAcquisition.disconnect();

    return asToken;
}

From source file:org.apache.hadoop.gateway.util.JsonPathTest.java

@Test
public void testEvaluateObjects() throws IOException {
    String json;/*from ww w  .  j  av  a  2s . c om*/
    JsonPath.Segment seg;
    List<JsonPath.Match> matches;
    JsonPath.Match match;
    JsonPath.Match parent;
    JsonNode root;
    JsonNode node;
    JsonPath.Expression expression;

    JsonFactory factory = new JsonFactory();
    ObjectMapper mapper = new ObjectMapper(factory);

    json = "{ \"field\" : \"value\" }";
    root = mapper.readTree(json);
    assertThat(root, notNullValue());

    expression = JsonPath.compile("$.field");
    matches = expression.evaluate(root);
    assertThat(matches, notNullValue());
    assertThat(matches.size(), is(1));
    match = matches.get(0);
    assertThat(matches, notNullValue());
    seg = matches.get(0).getSegment();
    assertThat(seg, notNullValue());
    assertThat(seg.getType(), is(JsonPath.Segment.Type.FIELD));
    assertThat(seg.getField(), is("field"));
    node = match.getNode();
    assertThat(node, notNullValue());
    assertThat(node.getNodeType(), is(JsonNodeType.STRING));
    assertThat(node.asText(), is("value"));
    parent = match.getParent();
    assertThat(parent, notNullValue());
    assertThat(parent.getNode(), sameInstance(root));
    assertThat(parent.getParent(), nullValue());
    assertThat(parent.getSegment().getType(), is(JsonPath.Segment.Type.ROOT));

    json = "{ \"outer\" : { \"inner\" : \"value\"}  }";
    root = mapper.readTree(json);
    assertThat(root, notNullValue());

    expression = JsonPath.compile("$.outer.inner");
    matches = expression.evaluate(root);
    match = matches.get(0);
    assertThat(match, notNullValue());
    assertThat(match.getField(), is("inner"));
    seg = match.getSegment();
    assertThat(seg, notNullValue());
    assertThat(seg.getField(), is("inner"));
    assertThat(seg.getType(), is(JsonPath.Segment.Type.FIELD));

    node = match.getNode();
    assertThat(node, notNullValue());
    assertThat(node.asText(), is("value"));

    parent = match.getParent();
    assertThat(parent, notNullValue());
    assertThat(parent.getField(), is("outer"));
    assertThat(parent.getNode().getNodeType(), is(JsonNodeType.OBJECT));

    parent = parent.getParent();
    assertThat(parent.getSegment().getType(), is(JsonPath.Segment.Type.ROOT));
    assertThat(parent.getNode().getNodeType(), is(JsonNodeType.OBJECT));

    json = "{ \"outer\" : { \"inner\" : \"value\"}  }";
    root = mapper.readTree(json);
    assertThat(root, notNullValue());

    expression = JsonPath.compile("$.*.inner");
    matches = expression.evaluate(root);
    assertThat(matches.size(), is(1));
    match = matches.get(0);
    assertThat(match.getField(), is("inner"));
    assertThat(match.getNode().asText(), is("value"));
}

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

public Boolean getBoolean(String key, ObjectNode node, boolean required, String location, ParseResult result) {
    Boolean value = null;/*  w w w .jav  a  2 s.com*/
    JsonNode v = node.get(key);
    if (node == null || v == null) {
        if (required) {
            result.missing(location, key);
            result.invalid();
        }
    } else {
        if (v.getNodeType().equals(JsonNodeType.BOOLEAN)) {
            value = v.asBoolean();
        } else if (v.getNodeType().equals(JsonNodeType.STRING)) {
            String stringValue = v.textValue();
            return Boolean.parseBoolean(stringValue);
        }
    }
    return value;
}

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

public Parameter parameter(ObjectNode obj, String location, ParseResult result) {
    if (obj == null) {
        return null;
    }//from  www .  j  a va2 s  .co  m

    Parameter output = null;
    JsonNode ref = obj.get("$ref");
    if (ref != null) {
        if (ref.getNodeType().equals(JsonNodeType.STRING)) {
            return refParameter((TextNode) ref, location, result);
        } else {
            result.invalidType(location, "$ref", "string", obj);
            return null;
        }
    }

    String l = null;
    JsonNode ln = obj.get("name");
    if (ln != null) {
        l = ln.asText();
    } else {
        l = "['unknown']";
    }
    location += ".[" + l + "]";

    String value = getString("in", obj, true, location, result);
    if (value != null) {
        String type = getString("type", obj, false, location, result);
        String format = getString("format", obj, false, location, result);
        AbstractSerializableParameter<?> sp = null;
        if ("query".equals(value)) {
            sp = new QueryParameter();
        } else if ("header".equals(value)) {
            sp = new HeaderParameter();
        } else if ("path".equals(value)) {
            sp = new PathParameter();
        } else if ("formData".equals(value)) {
            sp = new FormParameter();
        }

        if (sp != null) {
            // type is mandatory when sp != null
            getString("type", obj, true, location, result);
            Map<PropertyBuilder.PropertyId, Object> map = new HashMap<PropertyBuilder.PropertyId, Object>();

            map.put(TYPE, type);
            map.put(FORMAT, format);
            String defaultValue = getString("default", obj, false, location, result);
            map.put(DEFAULT, defaultValue);
            sp.setDefault(defaultValue);

            Double dbl = getDouble("maximum", obj, false, location, result);
            if (dbl != null) {
                map.put(MAXIMUM, dbl);
                sp.setMaximum(dbl);
            }

            Boolean bl = getBoolean("exclusiveMaximum", obj, false, location, result);
            if (bl != null) {
                map.put(EXCLUSIVE_MAXIMUM, bl);
                sp.setExclusiveMaximum(bl);
            }

            dbl = getDouble("minimum", obj, false, location, result);
            if (dbl != null) {
                map.put(MINIMUM, dbl);
                sp.setMinimum(dbl);
            }

            bl = getBoolean("exclusiveMinimum", obj, false, location, result);
            if (bl != null) {
                map.put(EXCLUSIVE_MINIMUM, bl);
                sp.setExclusiveMinimum(bl);
            }

            map.put(MAX_LENGTH, getInteger("maxLength", obj, false, location, result));
            map.put(MIN_LENGTH, getInteger("minLength", obj, false, location, result));

            String pat = getString("pattern", obj, false, location, result);
            map.put(PATTERN, pat);
            sp.setPattern(pat);

            Integer iv = getInteger("maxItems", obj, false, location, result);
            map.put(MAX_ITEMS, iv);
            sp.setMaxItems(iv);

            iv = getInteger("minItems", obj, false, location, result);
            map.put(MIN_ITEMS, iv);
            sp.setMinItems(iv);

            map.put(UNIQUE_ITEMS, getBoolean("uniqueItems", obj, false, location, result));

            ArrayNode an = getArray("enum", obj, false, location, result);
            if (an != null) {
                List<String> _enum = new ArrayList<String>();
                for (JsonNode n : an) {
                    _enum.add(n.textValue());
                }
                sp.setEnum(_enum);
                map.put(ENUM, _enum);
            }

            Property prop = PropertyBuilder.build(type, format, map);

            if (prop != null) {
                sp.setProperty(prop);
                ObjectNode items = getObject("items", obj, false, location, result);
                if (items != null) {
                    Property inner = schema(null, items, location, result);
                    sp.setItems(inner);
                }
            }

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

            String collectionFormat = getString("collectionFormat", obj, false, location, result);
            sp.setCollectionFormat(collectionFormat);

            output = sp;
        } else if ("body".equals(value)) {
            output = Json.mapper().convertValue(obj, Parameter.class);
        }
        if (output != null) {
            value = getString("name", obj, true, location, result);
            output.setName(value);

            value = getString("description", obj, false, location, result);
            output.setDescription(value);

            Boolean required = getBoolean("required", obj, false, location, result);
            if (required != null) {
                output.setRequired(required);
            }
        }
    }

    return output;
}

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

public PathItem getPathItem(ObjectNode obj, String location, ParseResult result) {

    PathItem pathItem = new PathItem();

    if (obj.get("$ref") != null) {
        JsonNode ref = obj.get("$ref");

        if (ref.getNodeType().equals(JsonNodeType.STRING)) {
            String mungedRef = mungedRef(ref.textValue());
            if (mungedRef != null) {
                pathItem.set$ref(mungedRef);
            } else {
                pathItem.set$ref(ref.textValue());
            }//  w  w w.  j  a  va2s.c  o m
            return pathItem;
        } else if (ref.getNodeType().equals(JsonNodeType.OBJECT)) {
            ObjectNode node = (ObjectNode) ref;

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

    String value = getString("summary", obj, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        pathItem.setSummary(value);
    }

    value = getString("description", obj, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        pathItem.setDescription(value);
    }

    ArrayNode parameters = getArray("parameters", obj, false, location, result);
    if (parameters != null && parameters.size() > 0) {
        pathItem.setParameters(getParameterList(parameters, location, result));
    }

    ArrayNode servers = getArray("servers", obj, false, location, result);
    if (servers != null && servers.size() > 0) {
        pathItem.setServers(getServersList(servers, location, result));
    }

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

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

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

    return pathItem;
}

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

public Model definition(ObjectNode node, String location, ParseResult result) {
    if (node == null) {
        result.missing(location, "empty schema");
    }//w ww.j  ava 2  s.c  om
    if (node.get("$ref") != null) {
        return refModel(node, location, result);
    }
    if (node.get("allOf") != null) {
        return allOfModel(node, location, result);
    }
    Model model = null;
    String value = null;

    String type = getString("type", node, false, location, result);
    Model m = new ModelImpl();
    if ("array".equals(type)) {
        ArrayModel am = new ArrayModel();
        ObjectNode propertyNode = getObject("properties", node, false, location, result);
        Map<String, Property> properties = properties(propertyNode, location, result);
        am.setProperties(properties);

        ObjectNode itemsNode = getObject("items", node, false, location, result);
        Property items = property(itemsNode, location, result);
        if (items != null) {
            am.items(items);
        }

        model = am;
    } else {
        ModelImpl impl = new ModelImpl();
        impl.setType(value);

        JsonNode ap = node.get("additionalProperties");
        if (ap != null && ap.getNodeType().equals(JsonNodeType.OBJECT)) {
            impl.setAdditionalProperties(Json.mapper().convertValue(ap, Property.class));
        }

        value = getString("default", node, false, location, result);
        impl.setDefaultValue(value);

        value = getString("format", node, false, location, result);
        impl.setFormat(value);

        value = getString("discriminator", node, false, location, result);
        impl.setDiscriminator(value);

        JsonNode xml = node.get("xml");
        if (xml != null) {
            impl.setXml(Json.mapper().convertValue(xml, Xml.class));
        }

        ObjectNode externalDocs = getObject("externalDocs", node, false, location, result);
        ExternalDocs docs = externalDocs(externalDocs, location, result);
        impl.setExternalDocs(docs);

        ObjectNode properties = getObject("properties", node, true, location, result);
        if (properties != null) {
            Set<String> propertyNames = getKeys(properties);
            for (String propertyName : propertyNames) {
                JsonNode propertyNode = properties.get(propertyName);
                if (propertyNode.getNodeType().equals(JsonNodeType.OBJECT)) {
                    ObjectNode on = (ObjectNode) propertyNode;
                    Property property = property(on, location, result);
                    impl.property(propertyName, property);
                } else {
                    result.invalidType(location, "properties", "object", propertyNode);
                }
            }
        }

        // need to set properties first
        ArrayNode required = getArray("required", node, false, location, result);
        if (required != null) {
            List<String> requiredProperties = new ArrayList<String>();
            for (JsonNode n : required) {
                if (n.getNodeType().equals(JsonNodeType.STRING)) {
                    requiredProperties.add(((TextNode) n).textValue());
                } else {
                    result.invalidType(location, "required", "string", n);
                }
            }
            if (requiredProperties.size() > 0) {
                impl.setRequired(requiredProperties);
            }
        }

        // extra keys
        Set<String> keys = getKeys(node);
        for (String key : keys) {
            if (key.startsWith("x-")) {
                impl.setVendorExtension(key, extension(node.get(key)));
            } else if (!SCHEMA_KEYS.contains(key)) {
                result.extra(location, key, node.get(key));
            }
        }
        if ("{ }".equals(Json.pretty(impl)))
            return null;
        model = impl;
    }
    JsonNode exampleNode = node.get("example");
    if (exampleNode != null) {
        // we support text or object nodes
        if (exampleNode.getNodeType().equals(JsonNodeType.OBJECT)) {
            ObjectNode on = getObject("example", node, false, location, result);
            if (on != null) {
                model.setExample(on);
            }
        } else {
            model.setExample(exampleNode.asText());
        }
    }

    if (model != null) {
        value = getString("description", node, false, location, result);
        model.setDescription(value);

        value = getString("title", node, false, location, result);
        model.setTitle(value);
    }

    return model;
}

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

public Object extension(JsonNode jsonNode) {
    if (jsonNode.getNodeType().equals(JsonNodeType.BOOLEAN)) {
        return jsonNode.asBoolean();
    }/*ww  w.ja  va2  s.  co m*/
    if (jsonNode.getNodeType().equals(JsonNodeType.STRING)) {
        return jsonNode.asText();
    }
    if (jsonNode.getNodeType().equals(JsonNodeType.NUMBER)) {
        NumericNode n = (NumericNode) jsonNode;
        if (n.isLong()) {
            return jsonNode.asLong();
        }
        if (n.isInt()) {
            return jsonNode.asInt();
        }
        if (n.isBigDecimal()) {
            return jsonNode.textValue();
        }
        if (n.isBoolean()) {
            return jsonNode.asBoolean();
        }
        if (n.isFloat()) {
            return jsonNode.floatValue();
        }
        if (n.isDouble()) {
            return jsonNode.doubleValue();
        }
        if (n.isShort()) {
            return jsonNode.intValue();
        }
        return jsonNode.asText();
    }
    if (jsonNode.getNodeType().equals(JsonNodeType.ARRAY)) {
        ArrayNode an = (ArrayNode) jsonNode;
        List<Object> o = new ArrayList<Object>();
        for (JsonNode i : an) {
            Object obj = extension(i);
            if (obj != null) {
                o.add(obj);
            }
        }
        return o;
    }
    return jsonNode;
}

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

public Response response(ObjectNode node, String location, ParseResult result) {
    if (node == null)
        return null;

    Response output = new Response();
    JsonNode ref = node.get("$ref");
    if (ref != null) {
        if (ref.getNodeType().equals(JsonNodeType.STRING)) {
            return refResponse((TextNode) ref, location, result);
        } else {/*from  w ww  .  jav a  2s . c  om*/
            result.invalidType(location, "$ref", "string", node);
            return null;
        }
    }

    String value = getString("description", node, true, location, result);
    output.description(value);

    ObjectNode schema = getObject("schema", node, false, location, result);
    if (schema != null) {
        output.schema(Json.mapper().convertValue(schema, Property.class));
    }
    ObjectNode headersNode = getObject("headers", node, false, location, result);
    if (headersNode != null) {
        // TODO
        Map<String, Property> headers = Json.mapper().convertValue(headersNode,
                Json.mapper().getTypeFactory().constructMapType(Map.class, String.class, Property.class));
        output.headers(headers);
    }

    ObjectNode examplesNode = getObject("examples", node, false, location, result);
    if (examplesNode != null) {
        Map<String, Object> examples = Json.mapper().convertValue(examplesNode,
                Json.mapper().getTypeFactory().constructMapType(Map.class, String.class, Object.class));
        output.setExamples(examples);
    }

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

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

public Link getLink(ObjectNode linkNode, String location, ParseResult result) {
    if (linkNode == null) {
        return null;
    }//from  w  w w.j av  a 2  s . c  o  m

    Link link = new Link();

    JsonNode ref = linkNode.get("$ref");
    if (ref != null) {
        if (ref.getNodeType().equals(JsonNodeType.STRING)) {
            String mungedRef = mungedRef(ref.textValue());
            if (mungedRef != null) {
                link.set$ref(mungedRef);
            } else {
                link.set$ref(ref.textValue());
            }

            return link;
        } else {
            result.invalidType(location, "$ref", "string", linkNode);
            return null;
        }
    }

    String value = getString("operationRef", linkNode, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        link.setOperationRef(value);
    }

    value = getString("operationId", linkNode, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        link.setOperationId(value);
    }

    ObjectNode parametersObject = getObject("parameters", linkNode, false, location, result);
    if (parametersObject != null) {
        link.setParameters(getLinkParameters(parametersObject, location, result));
    }

    String requestBody = getString("requestBody", linkNode, false, location, result);
    if (requestBody != null) {
        link.setRequestBody(requestBody);
    }

    ObjectNode headerObject = getObject("headers", linkNode, false, location, result);
    if (headerObject != null) {
        link.setHeaders(getHeaders(headerObject, location, result));
    }

    ObjectNode serverObject = getObject("server", linkNode, false, location, result);
    if (serverObject != null) {
        link.setServer(getServer(serverObject, location, result));
    }

    value = getString("description", linkNode, false, location, result);
    if (StringUtils.isNotBlank(value)) {
        link.setDescription(value);
    }

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

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

    return link;
}

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

public List<SecurityRequirement> securityRequirements(ArrayNode node, String location, ParseResult result) {
    if (node == null)
        return null;

    List<SecurityRequirement> output = new ArrayList<SecurityRequirement>();

    for (JsonNode item : node) {
        SecurityRequirement security = new SecurityRequirement();
        if (item.getNodeType().equals(JsonNodeType.OBJECT)) {
            ObjectNode on = (ObjectNode) item;
            Set<String> keys = getKeys(on);

            for (String key : keys) {
                List<String> scopes = new ArrayList<>();
                ArrayNode obj = getArray(key, on, false, location + ".security", result);
                if (obj != null) {
                    for (JsonNode n : obj) {
                        if (n.getNodeType().equals(JsonNodeType.STRING)) {
                            scopes.add(n.asText());
                        } else {
                            result.invalidType(location, key, "string", n);
                        }//from  w w w.  ja v a  2 s. c  o m
                    }
                }
                security.requirement(key, scopes);
            }
        }
        output.add(security);
    }

    return output;
}