private void setupObjectNodes(final JsonNode schema) {
JsonNode node = schema.path("properties");
if (node.isObject()) properties.putAll(CollectionUtils.toMap(node.fields()));
node = schema.path("patternProperties");
if (node.isObject()) patternProperties.putAll(CollectionUtils.toMap(node.fields()));
node = schema.path("additionalProperties");
if (node.isObject()) additionalProperties = node;
}
private static void mergeJsonObject(ObjectNode src, ObjectNode other) {
Iterator<Map.Entry<String, JsonNode>> ite = other.fields();
while (ite.hasNext()) {
Map.Entry<String, JsonNode> pair = ite.next();
JsonNode s = src.get(pair.getKey());
JsonNode v = pair.getValue();
if (v.isObject() && s != null && s.isObject()) {
mergeJsonObject((ObjectNode) s, (ObjectNode) v);
} else if (v.isArray() && s != null && s.isArray()) {
mergeJsonArray((ArrayNode) s, (ArrayNode) v);
} else {
src.replace(pair.getKey(), v);
}
}
}
@Override
public Tuple convert(String source) {
TupleBuilder builder = TupleBuilder.tuple();
try {
JsonNode root = mapper.readTree(source);
for (Iterator<Entry<String, JsonNode>> it = root.fields(); it.hasNext(); ) {
Entry<String, JsonNode> entry = it.next();
String name = entry.getKey();
JsonNode node = entry.getValue();
if (node.isObject()) {
// tuple
builder.addEntry(name, convert(node.toString()));
} else if (node.isArray()) {
builder.addEntry(name, nodeToList(node));
} else if (node.isNull()) {
builder.addEntry(name, null);
} else if (node.isBoolean()) {
builder.addEntry(name, node.booleanValue());
} else if (node.isNumber()) {
builder.addEntry(name, node.numberValue());
} else {
builder.addEntry(name, mapper.treeToValue(node, Object.class));
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return builder.build();
}
@Override
public SchemaAndValue toConnectData(String topic, byte[] value) {
JsonNode jsonValue;
try {
jsonValue = deserializer.deserialize(topic, value);
} catch (SerializationException e) {
throw new DataException(
"Converting byte[] to Kafka Connect data failed due to serialization error: ", e);
}
if (enableSchemas
&& (jsonValue == null
|| !jsonValue.isObject()
|| jsonValue.size() != 2
|| !jsonValue.has("schema")
|| !jsonValue.has("payload")))
throw new DataException(
"JsonDeserializer with schemas.enable requires \"schema\" and \"payload\" fields and may not contain additional fields");
// The deserialized data should either be an envelope object containing the schema and the
// payload or the schema
// was stripped during serialization and we need to fill in an all-encompassing schema.
if (!enableSchemas) {
ObjectNode envelope = JsonNodeFactory.instance.objectNode();
envelope.set("schema", null);
envelope.set("payload", jsonValue);
jsonValue = envelope;
}
return jsonToConnect(jsonValue);
}
@Override
public Tuple convert(String source) {
TupleBuilder builder = TupleBuilder.tuple();
try {
JsonNode root = mapper.readTree(source);
for (Iterator<Entry<String, JsonNode>> it = root.fields(); it.hasNext(); ) {
Entry<String, JsonNode> entry = it.next();
String name = entry.getKey();
JsonNode node = entry.getValue();
if (node.isObject()) {
// tuple
builder.addEntry(name, convert(node.toString()));
} else if (node.isArray()) {
builder.addEntry(name, nodeToList(node));
} else {
if (name.equals("id")) {
// TODO how should this be handled?
} else if (name.equals("timestamp")) {
// TODO how should this be handled?
} else {
builder.addEntry(name, node.asText());
}
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return builder.build();
}
@Test
public void unclosedObject_AutoClosesOnClose() throws IOException {
jsonGenerator.writeStartObject();
jsonGenerator.writeFieldName("stringProp").writeValue("stringVal");
JsonNode node = toJsonNode();
assertTrue(node.isObject());
}
private static void mergeJsonArray(ArrayNode src, ArrayNode other) {
for (int i = 0; i < other.size(); i++) {
JsonNode s = src.get(i);
JsonNode v = other.get(i);
if (s == null) {
src.add(v);
} else if (v.isObject() && s.isObject()) {
mergeJsonObject((ObjectNode) s, (ObjectNode) v);
} else if (v.isArray() && s.isArray()) {
mergeJsonArray((ArrayNode) s, (ArrayNode) v);
} else {
src.remove(i);
src.insert(i, v);
}
}
}
@Test
public void testCommandGetSingleDocument() {
running(
fakeApplication(),
() -> {
try {
DbHelper.open("1234567890", TEST_USER, TEST_USER);
ObjectNode cmd = MAPPER.createObjectNode();
ObjectNode p = MAPPER.createObjectNode();
p.put("collection", TEST_COLLECTION);
p.put("id", sGenIds.get(0));
cmd.put(ScriptCommand.RESOURCE, "documents");
cmd.put(ScriptCommand.NAME, "get");
cmd.put(ScriptCommand.PARAMS, p);
JsonNode node = CommandRegistry.execute(cmd, null);
assertNotNull(node);
assertTrue(node.isObject());
assertNotNull(node.get("generated"));
assertNotNull(node.get("id"));
assertEquals(node.get("id").asText(), sGenIds.get(0));
assertEquals(node.get("@class").asText(), TEST_COLLECTION);
} catch (Throwable t) {
fail(ExceptionUtils.getFullStackTrace(t));
} finally {
DbHelper.close(DbHelper.getConnection());
}
});
}
@Test
public void testCreateDocument() {
running(
fakeApplication(),
() -> {
try {
DbHelper.open("1234567890", TEST_USER, TEST_USER);
ObjectNode params = MAPPER.createObjectNode();
ObjectNode doc = MAPPER.createObjectNode();
doc.put("fresh", "fresh");
params.put("collection", TEST_COLLECTION);
params.put("data", doc);
ObjectNode cmd = ScriptCommands.createCommand("documents", "post", params);
JsonNode exec = CommandRegistry.execute(cmd, null);
assertNotNull(exec);
assertTrue(exec.isObject());
assertNotNull(exec.get("id"));
assertEquals(TEST_COLLECTION, exec.get("@class").asText());
} catch (Throwable t) {
fail(ExceptionUtils.getFullStackTrace(t));
} finally {
DbHelper.close(DbHelper.getConnection());
}
});
}
@Override
public AtomicColumnType fromJsonNode(JsonNode json) {
if (json.isObject() && json.has("value")) {
return null;
}
BaseType baseType = BaseType.fromJson(json, "key");
if (baseType != null) {
AtomicColumnType atomicColumnType = new AtomicColumnType(baseType);
JsonNode node = null;
if ((node = json.get("min")) != null) {
atomicColumnType.setMin(node.asLong());
}
if ((node = json.get("max")) != null) {
if (node.isNumber()) {
atomicColumnType.setMax(node.asLong());
} else if ("unlimited".equals(node.asText())) {
atomicColumnType.setMax(Long.MAX_VALUE);
}
}
return atomicColumnType;
}
return null;
}
public String parseData(JsonNode node, String f)
throws JsonProcessingException, IOException, JSONException {
System.out.println("---");
ObjectNode json = factory.objectNode();
type.push(f);
Iterator<String> fieldNames = node.fieldNames();
String uri = type.toString().replaceAll(", ", ".").replaceAll("[\\[\\]]", "");
json.put("type_uri", uri);
ObjectNode object = factory.objectNode();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
JsonNode fieldValue = node.get(fieldName);
// if (node.findParent("description").get("description") != null)
// json.set("value", node.findParent("description").get("description"));
if (fieldValue.isObject()) {
ObjectNode assoc = factory.objectNode();
assoc.set(uri + "." + parseData(fieldValue, fieldName).replaceAll("\n", ""), fieldValue);
json.set("composite", assoc);
} else {
json.set(fieldName, fieldValue);
}
}
// json.append("}");
System.out.println("xxx");
System.out.println(m.writerWithDefaultPrettyPrinter().writeValueAsString(json));
TopicModel t = new TopicModel(new JSONObject(json.toString()));
System.err.println(t.getUri());
System.err.println(t.getChildTopicsModel());
return type.pop();
}
@Test
public void testCommandAlterDocument() {
running(
fakeApplication(),
() -> {
try {
DbHelper.open("1234567890", TEST_USER, TEST_USER);
ObjectNode cmd = MAPPER.createObjectNode();
ObjectNode p = MAPPER.createObjectNode();
p.put("id", sGenIds.get(0));
p.put("collection", TEST_COLLECTION);
cmd.put(ScriptCommand.RESOURCE, "documents");
cmd.put(ScriptCommand.NAME, "get");
cmd.put(ScriptCommand.PARAMS, p);
JsonNode node = CommandRegistry.execute(cmd, null);
assertNotNull(node);
assertTrue(node.isObject());
ObjectNode doc = node.deepCopy();
doc.put("extra", "extra");
ObjectNode upd = MAPPER.createObjectNode();
upd.put(ScriptCommand.RESOURCE, "documents");
upd.put(ScriptCommand.NAME, "put");
ObjectNode params = MAPPER.createObjectNode();
params.put("collection", TEST_COLLECTION);
params.put("id", doc.get("id").asText());
params.put("data", doc);
upd.put(ScriptCommand.PARAMS, params);
JsonNode res = CommandRegistry.execute(upd, null);
assertNotNull(res);
assertTrue(res.isObject());
assertNotNull(res.get("extra"));
assertEquals(res.get("id"), doc.get("id"));
assertEquals("extra", res.get("extra").asText());
} catch (Throwable t) {
fail(ExceptionUtils.getFullStackTrace(t));
} finally {
DbHelper.close(DbHelper.getConnection());
}
});
}
@Override
public DataSourceImpl getNested(String attrName) {
JsonNode json = data.get(attrName);
if (json == null) {
throw new ConfigException("Attribute " + attrName + " is required but not set");
}
if (!json.isObject()) {
throw new ConfigException("Attribute " + attrName + " must be an object");
}
return newInstance(model, (ObjectNode) json);
}
@Override
public DataSourceImpl getNestedOrSetEmpty(String attrName) {
JsonNode json = data.get(attrName);
if (json == null) {
json = data.objectNode();
data.set(attrName, json);
} else if (!json.isObject()) {
throw new ConfigException("Attribute " + attrName + " must be an object");
}
return newInstance(model, (ObjectNode) json);
}
private void setupArrayNodes(final JsonNode schema) {
JsonNode node = schema.path("items");
/**
* We don't bother at this point: if items is a schema, then it will be used for each and every
* element of the instance to validate -- it's just as if additionalItems were never defined.
* So, as items is defined as a list above, we just leave it empty and assign the contents of
* the keyword to additionalItems.
*/
if (node.isObject()) {
additionalItems = node;
return;
}
if (node.isArray()) for (final JsonNode item : node) items.add(item);
node = schema.path("additionalItems");
if (node.isObject()) additionalItems = node;
}
/** Pushes one variable scope level. */
private void pushSection(String name) {
JsonNode node = currentNode.path(name);
ObjectNode obj = null;
if (node.isObject()) {
obj = (ObjectNode) node;
} else {
obj = JsonUtils.createObjectNode();
currentNode.put(name, obj);
}
variables.push(currentNode);
currentNode = obj;
}
public void testEmbeddedObjectInObject() throws Exception {
TokenBuffer buf = new TokenBuffer(MAPPER);
buf.writeStartObject();
buf.writeFieldName("pojo");
buf.writeObject(MARKER);
buf.writeEndObject();
JsonNode node = MAPPER.readTree(buf.asParser());
buf.close();
assertTrue(node.isObject());
assertEquals(1, node.size());
JsonNode n = node.get("pojo");
assertTrue(n.isPojo());
assertSame(MARKER, ((POJONode) n).getPojo());
}
private List<Object> nodeToList(JsonNode node) {
List<Object> list = new ArrayList<Object>(node.size());
for (int i = 0; i < node.size(); i++) {
JsonNode item = node.get(i);
if (item.isObject()) {
list.add(convert(item.toString()));
} else if (item.isArray()) {
list.add(nodeToList(item));
} else {
list.add(item.asText());
}
}
return list;
}
public static Map<String, ?> toMap(JsonNode node) throws IOException {
if (node.isObject()) {
Map<String, Object> map = new LinkedHashMap<>();
Iterator<String> fieldNames = node.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
JsonNode fieldNode = node.get(fieldName);
map.put(fieldName, toObject(fieldNode));
}
return map;
} else {
throw new IllegalArgumentException("Can only transform a JSON object into a map");
}
}
private SchemaAndValue jsonToConnect(JsonNode jsonValue) {
if (jsonValue == null) return SchemaAndValue.NULL;
if (!jsonValue.isObject()
|| jsonValue.size() != 2
|| !jsonValue.has(JsonSchema.ENVELOPE_SCHEMA_FIELD_NAME)
|| !jsonValue.has(JsonSchema.ENVELOPE_PAYLOAD_FIELD_NAME))
throw new DataException(
"JSON value converted to Kafka Connect must be in envelope containing schema");
Schema schema = asConnectSchema(jsonValue.get(JsonSchema.ENVELOPE_SCHEMA_FIELD_NAME));
return new SchemaAndValue(
schema, convertToConnect(schema, jsonValue.get(JsonSchema.ENVELOPE_PAYLOAD_FIELD_NAME)));
}
/**
* Return a map out of an object's members
*
* <p>If the node given as an argument is not a map, an empty map is returned.
*
* @param node the node
* @return a map
*/
public static Map<String, JsonNode> asMap(final JsonNode node) {
if (!node.isObject()) return Collections.emptyMap();
final Iterator<Map.Entry<String, JsonNode>> iterator = node.fields();
final Map<String, JsonNode> ret = Maps.newHashMap();
Map.Entry<String, JsonNode> entry;
while (iterator.hasNext()) {
entry = iterator.next();
ret.put(entry.getKey(), entry.getValue());
}
return ret;
}
/**
* Handles the given {@link JsonNode} and writes the responses to the given {@link OutputStream}.
*
* @param node the {@link JsonNode}
* @param ops the {@link OutputStream}
* @throws IOException on error
*/
protected void handleNode(JsonNode node, OutputStreamWrapper opsw) throws IOException {
// handle objects
if (node.isObject()) {
handleObject(ObjectNode.class.cast(node), opsw);
// handle arrays
} else if (node.isArray()) {
handleArray(ArrayNode.class.cast(node), opsw);
// bail on bad data
} else {
throw new IllegalArgumentException("Invalid JsonNode type: " + node.getClass().getName());
}
}
@Test
public void simpleObject_AllPrimitiveTypes() throws IOException {
jsonGenerator.writeStartObject();
jsonGenerator.writeFieldName("stringProp").writeValue("stringVal");
jsonGenerator.writeFieldName("integralProp").writeValue(42);
jsonGenerator.writeFieldName("booleanProp").writeValue(true);
jsonGenerator.writeFieldName("doubleProp").writeValue(123.456);
jsonGenerator.writeEndObject();
JsonNode node = toJsonNode();
assertTrue(node.isObject());
assertEquals("stringVal", node.get("stringProp").textValue());
assertEquals(42, node.get("integralProp").longValue());
assertEquals(true, node.get("booleanProp").booleanValue());
assertEquals(123.456, node.get("doubleProp").doubleValue(), DELTA);
}
/**
* Return true if value is not present or if underlying JSON is empty object, array or null.
* WARNING this method can throw same exceptions as {@link JsonNodeValue#get()} in a case if
* source is invalid JSON string.
*/
public boolean isEmpty() {
if (!isPresent()) {
return true;
}
JsonNode n = get();
if ((n.isObject() || n.isArray()) && n.size() == 0) {
return true;
}
if (n.isNull()) {
return true;
}
return false;
}
private Task getTaskFromJson(JsonNode node) throws JsonProcessingException {
if (node.isObject()) {
ObjectNode onode = (ObjectNode) node;
final JsonNode type = onode.remove("type");
final JsonNode attributes = onode.remove("attributes");
final JsonNode relationships = onode.remove("relationships");
final JsonNode links = onode.remove("links");
Iterator<Map.Entry<String, JsonNode>> fields = attributes.fields();
while (fields.hasNext()) {
Map.Entry<String, JsonNode> f = fields.next();
onode.put(f.getKey(), f.getValue().textValue());
}
return mapper.treeToValue(onode, Task.class);
} else {
throw new JsonMappingException("Not an object: " + node);
}
}
private static List<Geocache> parseCaches(final ObjectNode response) {
try {
// Check for empty result
final JsonNode results = response.path("results");
if (!results.isObject()) {
return Collections.emptyList();
}
// Get and iterate result list
final List<Geocache> caches = new ArrayList<>(results.size());
for (final JsonNode cache : results) {
caches.add(parseSmallCache((ObjectNode) cache));
}
return caches;
} catch (ClassCastException | NullPointerException e) {
Log.e("OkapiClient.parseCachesResult", e);
}
return Collections.emptyList();
}
@Override
protected final void checkValue(
final Collection<JsonPointer> pointers,
final ProcessingReport report,
final JsonSchemaTree tree)
throws ProcessingException {
final JsonNode node = getNode(tree);
final Map<String, JsonNode> map = Maps.newTreeMap();
map.putAll(JacksonUtils.asMap(node));
String key;
JsonNode value;
for (final Map.Entry<String, JsonNode> entry : map.entrySet()) {
key = entry.getKey();
value = entry.getValue();
if (value.isObject()) pointers.add(BASE_POINTER.append(key));
else checkDependency(report, entry.getKey(), tree);
}
}
private List<Object> nodeToList(JsonNode node) throws JsonProcessingException {
List<Object> list = new ArrayList<Object>(node.size());
for (int i = 0; i < node.size(); i++) {
JsonNode item = node.get(i);
if (item.isObject()) {
list.add(convert(item.toString()));
} else if (item.isArray()) {
list.add(nodeToList(item));
} else if (item.isNull()) {
list.add(null);
} else if (item.isBoolean()) {
list.add(item.booleanValue());
} else if (item.isNumber()) {
list.add(item.numberValue());
} else {
list.add(mapper.treeToValue(item, Object.class));
}
}
return list;
}
/**
* Determines whether or not the given {@link JsonNode} matches the given type. This method is
* limitted to a few java types only and shouldn't be used to determine with great accuracy
* whether or not the types match.
*
* @param node the {@link JsonNode}
* @param type the {@link Class}
* @return true if the types match, false otherwise
*/
protected boolean isMatchingType(JsonNode node, Class<?> type) {
if (node.isNull()) {
return true;
} else if (node.isTextual()) {
return String.class.isAssignableFrom(type);
} else if (node.isNumber()) {
return Number.class.isAssignableFrom(type)
|| short.class.isAssignableFrom(type)
|| int.class.isAssignableFrom(type)
|| long.class.isAssignableFrom(type)
|| float.class.isAssignableFrom(type)
|| double.class.isAssignableFrom(type);
} else if (node.isArray() && type.isArray()) {
return (node.size() > 0) ? isMatchingType(node.get(0), type.getComponentType()) : false;
} else if (node.isArray()) {
return type.isArray() || Collection.class.isAssignableFrom(type);
} else if (node.isBinary()) {
return byte[].class.isAssignableFrom(type)
|| Byte[].class.isAssignableFrom(type)
|| char[].class.isAssignableFrom(type)
|| Character[].class.isAssignableFrom(type);
} else if (node.isBoolean()) {
return boolean.class.isAssignableFrom(type) || Boolean.class.isAssignableFrom(type);
} else if (node.isObject() || node.isPojo()) {
return !type.isPrimitive()
&& !String.class.isAssignableFrom(type)
&& !Number.class.isAssignableFrom(type)
&& !Boolean.class.isAssignableFrom(type);
}
// not sure if it's a matching type
return false;
}
private ViewArray processArrayNode(ArrayNode arrayNode) {
ViewArray node = new ViewArray();
if (arrayNode.size() != 1) {
throw new IllegalArgumentException(
"Arrays in example view data need to contain one and only one element");
}
JsonNode element = arrayNode.get(0);
if (element == null || element.isNull()) {
throw new IllegalArgumentException(
"Arrays in example view data cannot contain null elements");
}
if (element.isArray()) {
throw new IllegalArgumentException(
"Arrays in example view data cannot be directly nested within other arrays.");
} else if (element.isObject()) {
node.element = processObjectNode((ObjectNode) element);
}
return node;
}
