Refine search
log.trace("Resolving exception from JSON response {}", response); final JsonNode error = response.get(JsonRpcBasicServer.ERROR); if (error == null || !error.isObject()) { log.warn("No error information found in JSON response {}", response); return null; final JsonNode code = error.get(JsonRpcBasicServer.ERROR_CODE); if (code == null || !code.isInt() || code.asInt() != ThrowableSerializationMixin.ERROR_CODE) { log.warn("Not resolving exception for unsupported error code {}", code); return null; if (!dataObject.has(JsonRpcBasicServer.ERROR_MESSAGE)) { dataObject.set( JsonRpcBasicServer.ERROR_MESSAGE, new TextNode(error.get(JsonRpcBasicServer.ERROR_MESSAGE).asText())); return mapper.treeToValue(data, Throwable.class); } catch (final JsonProcessingException e) { log.warn("Unable to convert JSON response error '{}' into Throwable", data, e);
private JsonNode merge(JsonNode source, JsonNode replacement) throws IOException { JsonNode replacementNodeEncoded = replacement.get(fieldName); if (replacementNodeEncoded != null) { ObjectNode decodedSource = tryDecode(source.get(fieldName), mapper.createObjectNode(), fieldName); decodedSource.setAll(tryDecode(replacement.get(fieldName), mapper.createObjectNode(), fieldName)); return TextNode.valueOf(mapper.writeValueAsString(decodedSource)); } else { return source.get(fieldName); } }
throws IOException, JsonProcessingException { JsonNode node = jp.getCodec().readTree(jp); JsonNode allOf = node.get("allOf"); JsonNode anyOf = node.get("anyOf"); JsonNode oneOf = node.get("oneOf"); ComposedSchema composedSchema = Json.mapper().convertValue(node, ComposedSchema.class); return composedSchema; String format = node.get("format") == null ? "" : node.get("format").textValue(); if (type != null && "array".equals(((TextNode) type).textValue())) { schema = Json.mapper().convertValue(node, ArraySchema.class); } else if (type != null) { if (type.textValue().equals("integer")) { schema = Json.mapper().convertValue(node, IntegerSchema.class); if (StringUtils.isBlank(format)) { schema.setFormat(null);
@Override public List<JsonNode> apply(final Scope scope, final JsonNode in) throws JsonQueryException { final List<JsonNode> out = new ArrayList<>(); for (final Range range : ranges) { if (in.isArray()) { final Range r = range.over(in.size()); final ArrayNode array = scope.getObjectMapper().createArrayNode(); for (int index = (int) r.begin; index < (int) r.end; ++index) array.add(in.get(index)); out.add(array); } else if (in.isTextual()) { final String _in = in.asText(); final Range r = range.over(UnicodeUtils.lengthUtf32(_in)); out.add(new TextNode(UnicodeUtils.substringUtf32(_in, (int) r.begin, (int) r.end))); } else if (in.isNull()) { out.add(NullNode.getInstance()); } else { if (!permissive) throw JsonQueryException.format("Cannot index %s with object", in.getNodeType()); } } return out; }
@Override public void doAction(JsonNode node) throws Exception { ArrayNode aux = null; HashSet<String> modulesToAdd = new HashSet<String>(modules); if (node.has("modules")) { JsonNode list = node.get("modules"); Iterator<JsonNode> it = list.iterator(); while (it.hasNext()) { JsonNode next = it.next(); modulesToAdd.remove(next.asText().trim()); } if (!modulesToAdd.isEmpty()) { if (list.isArray()) { aux = (ArrayNode) list; } } } else { aux = new ArrayNode(provider.getObjectMapper().getNodeFactory()); } if (!modulesToAdd.isEmpty()) { for (String moduleToAdd : modulesToAdd) { TextNode prov = new TextNode(moduleToAdd); aux.add(prov); } ObjectNode auxNode = (ObjectNode) node; auxNode.set("modules", aux); provider.write(node); } }
private JsonNode merge(JsonNode source, JsonNode replacement) throws IOException { JsonNode replacementNodeEncoded = replacement.get(fieldName); if (replacementNodeEncoded != null) { HashMap<String, JsonNode> result = new HashMap<String, JsonNode>(); result.putAll(groupArrayElementsByKey(tryDecode(source.get(fieldName), mapper.createArrayNode(), fieldName), key)); result.putAll(groupArrayElementsByKey(tryDecode(replacement.get(fieldName), mapper.createArrayNode(), fieldName), key)); return TextNode.valueOf(mapper.writeValueAsString(result.values())); } else { return source.get(fieldName); } }
if (obj.has(remainingPath) && !remainingPath.equals(key)) { if (obj.get(remainingPath).isValueNode()) { obj.put(remainingPath, value); return; "; node with index not found."); if (!child.isArray()) { throw new IllegalArgumentException("Unable to override " + name + "; node with index is not an array."); } else if (index >= child.size()) { throw new ArrayIndexOutOfBoundsException("Unable to override " + name + "; index is greater than size of array."); } else { final ArrayNode array = (ArrayNode) child; array.set(index, TextNode.valueOf(value)); return; if (node.get(key) != null && node.get(key).isArray()) { final ArrayNode arrayNode = (ArrayNode) obj.get(key); arrayNode.removeAll(); Arrays.stream(ESCAPED_COMMA_SPLIT_PATTERN.split(value)) .map(String::trim)
@Test public void mergeDefinitions_ReplacesKeysFromSourceWithReplacement() throws Exception { // Given ObjectNode a = mapper.createObjectNode(); ObjectNode b = mapper.createObjectNode(); a.put("a", "a"); b.put("a", "b"); // When JsonNode result = JsonMerger.merge(a, b, mergeStrategy()); // Then assertThat(result).hasSize(1); assertThat(result.get("a")).isEqualTo(TextNode.valueOf("b")); }
ArrayNode jsonArray = OBJECT_MAPPER.createArrayNode(); for (Object value : collection) { jsonArray.add(toJson(value)); ByteArrayOutputStream out = new ByteArrayOutputStream(); IOUtils.copy(inputStream, out); return new TextNode(new String(Base64.encodeBase64(out.toByteArray()), Charsets.UTF_8)); } else if (object instanceof Boolean) { return BooleanNode.valueOf((Boolean) object); } else if (object instanceof String) { return new TextNode((String) object); } else if (object instanceof Long) { return new LongNode((Long) object); return new FloatNode((Float) object); } else if (object instanceof Enum) { return new TextNode(object.toString()); } else if (object == null) { return NullNode.getInstance(); } else if (object instanceof byte[]) { byte[] data = (byte[]) object; return new TextNode(new String(Base64.encodeBase64(data), Charsets.UTF_8));
@Override public JsonNode apply(ObjectMapper mapper, JsonNode lhs, JsonNode rhs) throws JsonQueryException { if (lhs.isNumber() && rhs.isNumber()) { final double divisor = rhs.asDouble(); final double dividend = lhs.asDouble(); if (divisor == 0.0) throw JsonQueryException.format("number (%s) and number (%s) cannot be divided because the divisor is zero", dividend, divisor); return JsonNodeUtils.asNumericNode(dividend / divisor); } else if (lhs.isTextual() && rhs.isTextual()) { final ArrayNode result = mapper.createArrayNode(); for (final String token : lhs.asText().split(Pattern.quote(rhs.asText()))) result.add(new TextNode(token)); return result; } else { throw new JsonQueryTypeException(lhs, rhs, "cannot be divided"); } }
@Test public void matchesIsFalseIfNoFingerprintMatches() throws CertificateException { final X509Certificate cert = CertificateParser.parsePem(ATTESTATION_CERT); ArrayNode fingerprints = new ArrayNode(JsonNodeFactory.instance); fingerprints.add(new TextNode("foo")); fingerprints.add(new TextNode("bar")); JsonNode parameters = mock(JsonNode.class); when(parameters.get("fingerprints")).thenReturn(fingerprints); assertFalse(new FingerprintMatcher().matches(cert, parameters)); }
@Override public List<JsonNode> apply(final Scope scope, final List<JsonQuery> args, final JsonNode in) throws JsonQueryException { Preconditions.checkInputType("split", in, JsonNodeType.STRING); final List<JsonNode> out = new ArrayList<>(); for (final JsonNode sep : args.get(0).apply(scope, in)) { if (!sep.isTextual()) throw new JsonQueryException("1st argument of split() must evaluate to string, not " + sep.getNodeType()); final ArrayNode row = scope.getObjectMapper().createArrayNode(); for (final String seg : split(in.asText(), sep.asText())) row.add(new TextNode(seg)); out.add(row); } return out; }
private void productIdInLineItems(final JsonNode resourceDraftNode) { final JsonNode lineItems = resourceDraftNode.get("lineItems"); if (lineItems != null && lineItems.isArray()) { final List<JsonNode> parents = resourceDraftNode.findParents(PRODUCT_ID_FIELD_NAME); parents.forEach(node -> { final String newId = keyToIdMap.get(node.get(PRODUCT_ID_FIELD_NAME).asText()); ((ObjectNode) node).replace(PRODUCT_ID_FIELD_NAME, new TextNode(newId)); }); } }
private void customerIdInOrders(final JsonNode resourceDraftNode) { final String fieldName = "customerId"; final List<JsonNode> nodesContainingCustomerId = resourceDraftNode.findParents(fieldName); nodesContainingCustomerId.forEach(node -> { if (node != null && node.isObject()) { final String newId = keyToIdMap.get(node.get(fieldName).asText()); ((ObjectNode) node).replace(fieldName, new TextNode(newId)); } }); }
@Override public List<JsonNode> apply(final Scope scope, final List<JsonQuery> args, final JsonNode in) throws JsonQueryException { Preconditions.checkInputType("keys", in, JsonNodeType.OBJECT, JsonNodeType.ARRAY); if (in.isObject()) { final List<String> keys = Lists.newArrayList(in.fieldNames()); Collections.sort(keys); final ArrayNode result = scope.getObjectMapper().createArrayNode(); for (final String key : keys) result.add(new TextNode(key)); return Collections.singletonList((JsonNode) result); } else if (in.isArray()) { final ArrayNode result = scope.getObjectMapper().createArrayNode(); for (int i = 0; i < in.size(); ++i) result.add(new IntNode(i)); return Collections.singletonList((JsonNode) result); } else { throw new IllegalStateException(); } } }
@Override public List<JsonNode> apply(final Scope scope, final List<JsonQuery> args, final JsonNode in) throws JsonQueryException { Preconditions.checkInputType("to_entries", in, JsonNodeType.OBJECT, JsonNodeType.ARRAY); final ArrayNode out = scope.getObjectMapper().createArrayNode(); if (in.isObject()) { final Iterator<Entry<String, JsonNode>> iter = in.fields(); while (iter.hasNext()) { final Entry<String, JsonNode> entry = iter.next(); final ObjectNode entryNode = scope.getObjectMapper().createObjectNode(); entryNode.set("key", new TextNode(entry.getKey())); entryNode.set("value", entry.getValue()); out.add(entryNode); } } else if (in.isArray()) { final Iterator<JsonNode> iter = in.elements(); int i = 0; while (iter.hasNext()) { final JsonNode entry = iter.next(); final ObjectNode entryNode = scope.getObjectMapper().createObjectNode(); entryNode.set("key", IntNode.valueOf(i++)); entryNode.set("value", entry); out.add(entryNode); } } else { throw new IllegalStateException(); } return Collections.singletonList((JsonNode) out); } }
private static JsonNode resolveSecrets(JsonNode node, SecretProvider secrets) { if (node.isObject()) { ObjectNode object = (ObjectNode) node; ObjectNode newObject = object.objectNode(); object.fields().forEachRemaining(entry -> newObject.set( UserSecretTemplate.of(entry.getKey()).format(secrets), resolveSecrets(entry.getValue(), secrets))); return newObject; } else if (node.isArray()) { ArrayNode array = (ArrayNode) node; ArrayNode newArray = array.arrayNode(); array.elements().forEachRemaining(element -> newArray.add(resolveSecrets(element, secrets))); return newArray; } else if (node.isTextual()) { return new TextNode(UserSecretTemplate.of(node.textValue()).format(secrets)); } else { return node; } }
if (node.isTextual()) { String fixedValue = fixer.fix(node.getTextValue()); return new TextNode(fixedValue); if (node.isArray()) { ArrayNode array = (ArrayNode)node; for (int i = 0; i < array.size(); i++) { JsonNode value = array.get(i); JsonNode fixedValue = walkJsonNode(value, fixer); array.set(i, fixedValue); } else if (node.isObject()) { ObjectNode object = (ObjectNode)node; Iterator<String> ite = object.getFieldNames(); while (ite.hasNext()) { String fieldName = ite.next(); JsonNode value = object.get(fieldName); JsonNode fixedValue = walkJsonNode(value, fixer); object.put(fieldName, fixedValue);
@Test public void interceptorsPostHandleExceptionTest() throws IOException { final String requestGood = "{\n" + " \"id\": 0,\n" + " \"jsonrpc\": \"2.0\",\n" + " \"method\": \"testMethod\",\n" + " \"params\": [\"test.cool\"]\n" + " }\n" + "}"; String exceptionMessage = "123"; String returnString = "test"; String responseError = "{\"jsonrpc\":\"2.0\",\"id\":0,\"error\":{\"code\":-32001,\"message\":\"" + exceptionMessage + "\",\"data\":{\"exceptionTypeName\":\"java.lang.RuntimeException\",\"message\":\"" + exceptionMessage + "\"}}}"; // expect(mockService.testMethod(mapper.readTree(requestGood).at("/params/0").asText())).andReturn(returnString); mockInterceptor.postHandle( anyObject(), anyObject(Method.class), eq(new ArrayList<JsonNode>() {{ add(mapper.readTree(requestGood).at("/params/0")); }}), eq(new TextNode(returnString)) ); expectLastCall().andThrow(new RuntimeException(exceptionMessage)); replay(mockService, mockInterceptor); jsonRpcServer.handleRequest(new ByteArrayInputStream(requestGood.getBytes(StandardCharsets.UTF_8)), byteArrayOutputStream); assertEquals(responseError, byteArrayOutputStream.toString("UTF-8").trim()); verify(mockService, mockInterceptor); }
private void addLambdaCodeURI(JsonNode resources) { for (Entry<String, File> function : lambdaFunctions.entrySet()) { TextNode codeUri = new TextNode(function.getValue().getAbsolutePath()); ObjectNode apiProperties = (ObjectNode) resources.get(function.getKey()).get("Properties"); apiProperties.set("CodeUri", codeUri); } }