@Test public void serializeClickActionLineGraphics_resultJsonHasClickAction() throws IOException { //when Line line = new Line(); line.onClick( new GraphicsActionListener() { @Override public void execute(GraphicsActionObject actionObject) {} }); graphicsSerializer.serialize(line, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); //then JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("hasClickAction")).isTrue(); Assertions.assertThat(actualObj.get("hasClickAction").asBoolean()).isTrue(); }
public static Result create() { // Get the form from the request Form<Record> form = Form.form(Record.class,Record.creation.class).bindFromRequest(); // Validate errors if(form.hasErrors()) { return badRequest(form.errorsAsJson()); } // Get the object from the form Record object = form.get(); // Create the object in db Ebean.beginTransaction(); try { Record.create(object); JsonNode jsonObject = object.jsonSerialization(); Ebean.commitTransaction(); return created(jsonObject); } catch (Exception e) { appLogger.error(Messages.get("Error creating object"), e); return internalServerError("Error creating object"); } finally { Ebean.endTransaction(); } }
@Test @SuppressWarnings("resource") public void testExtractSuccess() throws Exception { //Read file into a string File sampleFile = new File(getClass().getResource("/sample-aem-credentials.json").getFile()); String sampleFileContent = new Scanner(sampleFile).useDelimiter("\\Z").next(); ObjectMapper mapper = new ObjectMapper(); JsonNode root = mapper.readTree(sampleFileContent); AemCredentials aemCredentials = CredentialsExtractor.extractAemCredentials(sampleFileContent); assertThat(aemCredentials.getOrchestratorCredentials().getUserName(), equalTo(CredentialsExtractor.ORCHESTRATOR_USER)); assertThat(aemCredentials.getOrchestratorCredentials().getPassword(), equalTo(root.path(CredentialsExtractor.ORCHESTRATOR_USER).asText())); assertThat(aemCredentials.getReplicatorCredentials().getUserName(), equalTo(CredentialsExtractor.REPLICATOR_USER)); assertThat(aemCredentials.getReplicatorCredentials().getPassword(), equalTo(root.path(CredentialsExtractor.REPLICATOR_USER).asText())); }
@Test public void testcreatePageSection() { PowerMockito.mockStatic(RequestInterceptor.class); when( RequestInterceptor.verifyRequestData(Mockito.anyObject()) ).thenReturn("{userId} uuiuhcf784508 8y8c79-fhh"); Map<String , Object> requestMap = new HashMap<>(); Map<String , Object> innerMap = new HashMap<>(); innerMap.put("name" , "page1"); innerMap.put("sectionDataType" , "section01"); requestMap.put(JsonKey.REQUEST , innerMap); String data = mapToJson(requestMap); JsonNode json = Json.parse(data); RequestBuilder req = new RequestBuilder().bodyJson(json).uri("/v1/page/section/create").method("POST"); req.headers(headerMap); Result result = route(req); assertEquals(200, result.status()); }
@Test public void listSearchTypes() throws Exception { JsonNode results = getEntity(context.getBaseUrl() + "api/search/myresources", getToken()); List<String> subSearches = Lists.newArrayList(); for( JsonNode result : results ) { subSearches.add(result.get("id").asText()); } ArrayList<String> expected = Lists.newArrayList("published", "draft", "archived", "all", "modqueue"); for( String name : expected ) { assertTrue(subSearches.contains(name), "Should contain '" + name + ", " + subSearches); } }
/** * Processes an JsonNode message received on the channel. * * @param jsonNode The OvsdbJsonRpcHandler that received the message */ private void processOvsdbMessage(JsonNode jsonNode) { log.debug("Handle ovsdb message"); if (jsonNode.has("result")) { log.debug("Handle ovsdb result"); ovsdbProviderService.processResult(jsonNode); } else if (jsonNode.hasNonNull("method")) { log.debug("Handle ovsdb request"); if (jsonNode.has("id") && !Strings.isNullOrEmpty(jsonNode.get("id").asText())) { ovsdbProviderService.processRequest(jsonNode); } } return; }
@POST @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public Response createRouter(final InputStream input) { try { ObjectMapper mapper = new ObjectMapper(); JsonNode subnode = mapper.readTree(input); Collection<Router> routers = createOrUpdateByInputStream(subnode); Boolean result = nullIsNotFound((get(RouterService.class) .createRouters(routers)), CREATE_FAIL); if (!result) { return Response.status(CONFLICT).entity(CREATE_FAIL).build(); } return Response.status(CREATED).entity(result.toString()).build(); } catch (Exception e) { return Response.status(BAD_REQUEST).entity(e.getMessage()).build(); } }
public void validate(T object, ValidationResults results, Set<Class<? extends JsonNode>> allowedNodeTypes) { JsonOverlay<?> overlay = (JsonOverlay<?>) object; JsonNode json = overlay.toJson(); boolean isValidJsonType = false; for (Class<? extends JsonNode> type : allowedNodeTypes) { if (type.isAssignableFrom(json.getClass())) { isValidJsonType = true; break; } } isValidJsonType = isValidJsonType || json.isMissingNode(); if (!isValidJsonType) { results.addError(m.msg("WrongTypeJson|Property bound to incompatible JSON Node type", json.getNodeType(), allowedNodeTypes)); } }
/** * This method will add a new batch for a particular course. * * @return Promise<Result> */ public Promise<Result> createBatch() { try { JsonNode requestData = request().body().asJson(); ProjectLogger.log("create new batch request data=" + requestData, LoggerEnum.INFO.name()); Request reqObj = (Request) mapper.RequestMapper.mapRequest(requestData, Request.class); RequestValidator.validateCreateBatchReq(reqObj); reqObj.setOperation(ActorOperations.CREATE_BATCH.getValue()); reqObj.setRequestId(ExecutionContext.getRequestId()); reqObj.setEnv(getEnvironment()); HashMap<String, Object> innerMap = new HashMap<>(); if (!ProjectUtil.isStringNullOREmpty((String) reqObj.getRequest().get(JsonKey.BATCH_ID))) { reqObj.getRequest().put(JsonKey.ID, reqObj.getRequest().get(JsonKey.BATCH_ID)); reqObj.getRequest().remove(JsonKey.BATCH_ID); } innerMap.put(JsonKey.BATCH, reqObj.getRequest()); innerMap.put(JsonKey.REQUESTED_BY, ctx().flash().get(JsonKey.USER_ID)); innerMap.put(JsonKey.HEADER, getAllRequestHeaders(request())); reqObj.setRequest(innerMap); return actorResponseHandler(getActorRef(), reqObj, timeout, null, request()); } catch (Exception e) { return Promise.<Result>pure(createCommonExceptionResponse(e, request())); } }
/** * Creates a new port pair group. * * @param stream port pair group from JSON * @return status of the request - CREATED if the JSON is correct, * BAD_REQUEST if the JSON is invalid */ @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response createPortPairGroup(InputStream stream) { try { ObjectMapper mapper = new ObjectMapper(); ObjectNode jsonTree = (ObjectNode) mapper.readTree(stream); JsonNode port = jsonTree.get("port_pair_group"); PortPairGroup portPairGroup = codec(PortPairGroup.class).decode((ObjectNode) port, this); Boolean issuccess = nullIsNotFound(get(PortPairGroupService.class).createPortPairGroup(portPairGroup), PORT_PAIR_GROUP_NOT_FOUND); return Response.status(OK).entity(issuccess.toString()).build(); } catch (IOException e) { log.error("Exception while creating port pair group {}.", e.toString()); throw new IllegalArgumentException(e); } }
@Test public void propertyNamesAreLowerCamelCase() throws Exception { ClassLoader resultsClassLoader = schemaRule.generateAndCompile("/schema/properties/propertiesAreUpperCamelCase.json", "com.example"); Class<?> generatedType = resultsClassLoader.loadClass("com.example.UpperCase"); Object instance = generatedType.newInstance(); new PropertyDescriptor("property1", generatedType).getWriteMethod().invoke(instance, "1"); new PropertyDescriptor("propertyTwo", generatedType).getWriteMethod().invoke(instance, 2); new PropertyDescriptor("propertyThreeWithSpace", generatedType).getWriteMethod().invoke(instance, "3"); new PropertyDescriptor("propertyFour", generatedType).getWriteMethod().invoke(instance, "4"); JsonNode jsonified = mapper.valueToTree(instance); assertNotNull(generatedType.getDeclaredField("property1")); assertNotNull(generatedType.getDeclaredField("propertyTwo")); assertNotNull(generatedType.getDeclaredField("propertyThreeWithSpace")); assertNotNull(generatedType.getDeclaredField("propertyFour")); assertThat(jsonified.has("Property1"), is(true)); assertThat(jsonified.has("PropertyTwo"), is(true)); assertThat(jsonified.has(" PropertyThreeWithSpace"), is(true)); assertThat(jsonified.has("propertyFour"), is(true)); }
private void addEnumConstants(JsonNode node, JDefinedClass _enum, JsonNode customNames, JType type) { Collection<String> existingConstantNames = new ArrayList<String>(); for (int i = 0; i < node.size(); i++) { JsonNode value = node.path(i); if (!value.isNull()) { String constantName = getConstantName(value.asText(), customNames.path(i).asText()); constantName = makeUnique(constantName, existingConstantNames); existingConstantNames.add(constantName); JEnumConstant constant = _enum.enumConstant(constantName); constant.arg(DefaultRule.getDefaultValue(type, value)); ruleFactory.getAnnotator().enumConstant(constant, value.asText()); } } }
@Test public void buildSetCustomFieldsUpdateActions_WithDifferentOrderOfCustomFieldValues_ShouldNotBuildUpdateActions() { final Map<String, JsonNode> oldCustomFields = new HashMap<>(); oldCustomFields.put("backgroundColor", JsonNodeFactory.instance.objectNode().put("de", "rot").put("es", "rojo")); final Map<String, JsonNode> newCustomFields = new HashMap<>(); newCustomFields.put("backgroundColor", JsonNodeFactory.instance.objectNode().put("es", "rojo").put("de", "rot")); final List<UpdateAction<Category>> setCustomFieldsUpdateActions = buildSetCustomFieldsUpdateActions(oldCustomFields, newCustomFields, mock(Category.class), CATEGORY_SYNC_OPTIONS); assertThat(setCustomFieldsUpdateActions).isNotNull(); assertThat(setCustomFieldsUpdateActions).isEmpty(); }
public static void assertJsonEquals(String expected, String actual, String... blacklistedFields) { LOG.debug("Comparing expected [{}] to actual [{}]", expected, actual); DocumentContext expectedDocument = JsonPath.parse(expected); DocumentContext actualDocument = JsonPath.parse(actual); if (blacklistedFields != null) { removeFields(expectedDocument, blacklistedFields); removeFields(actualDocument, blacklistedFields); } try { ObjectMapper mapper = new ObjectMapper(); JsonNode expectedNode = mapper.readTree(expectedDocument.jsonString()); JsonNode actualNode = mapper.readTree(actualDocument.jsonString()); assertEquals(expectedNode, actualNode); } catch (Exception e) { throw new RuntimeException(e); } }
private void send(ExamEnrolment enrolment) throws IOException { String ref = enrolment.getReservation().getExternalRef(); Logger.debug("Sending back assessment for reservation " + ref); URL url = parseUrl(ref); WSRequest request = wsClient.url(url.toString()); ExternalExam ee = enrolment.getExternalExam(); Function<WSResponse, Void> onSuccess = response -> { if (response.getStatus() != 201) { Logger.error("Failed in sending assessment for reservation " + ref); } else { ee.setSent(DateTime.now()); ee.update(); Logger.info("Assessment for reservation " + ref + " processed successfully"); } return null; }; String json = Ebean.json().toJson(ee, PathProperties.parse("(*, creator(id))")); ObjectMapper om = new ObjectMapper(); JsonNode node = om.readTree(json); request.post(node).thenApplyAsync(onSuccess); }
@Override public JsonNode write( final Object obj ) throws IOException{ ArrayNode array = new ArrayNode( JsonNodeFactory.instance ); if( ! ( obj instanceof List ) ){ return array; } List<Object> listObj = (List)obj; for( Object childObj : listObj ){ if( childObj instanceof List ){ array.add( JacksonContainerToJsonObject.getFromList( (List<Object>)childObj ) ); } else if( childObj instanceof Map ){ array.add( JacksonContainerToJsonObject.getFromMap( (Map<Object,Object>)childObj ) ); } else{ array.add( ObjectToJsonNode.get( childObj ) ); } } return array; }
/** * This method will allow admin to create sections for page view * * @return Promise<Result> */ public Promise<Result> createPageSection() { try { JsonNode requestData = request().body().asJson(); ProjectLogger.log("getting create page section data request=" + requestData, LoggerEnum.INFO.name()); Request reqObj = (Request) mapper.RequestMapper.mapRequest(requestData, Request.class); RequestValidator.validateCreateSection(reqObj); reqObj.setOperation(ActorOperations.CREATE_SECTION.getValue()); reqObj.setRequestId(ExecutionContext.getRequestId()); reqObj.getRequest().put(JsonKey.CREATED_BY, ctx().flash().get(JsonKey.USER_ID)); reqObj.setEnv(getEnvironment()); HashMap<String, Object> map = new HashMap<>(); map.put(JsonKey.SECTION, reqObj.getRequest()); reqObj.setRequest(map); return actorResponseHandler(getActorRef(), reqObj, timeout, null, request()); } catch (Exception e) { return Promise.<Result>pure(createCommonExceptionResponse(e, request())); } }
public static void insertOrUpdateApp(JsonNode app, boolean isInsert) throws Exception { Map<String, Object> params = new HashMap<>(); params.put("appId", JsonUtil.getJsonValue(app, "app_id", Integer.class)); params.put("appCode", JsonUtil.getJsonValue(app, "app_code", String.class, null)); params.put("description", JsonUtil.getJsonValue(app, "description", String.class, null)); params.put("uri", JsonUtil.getJsonValue(app, "uri", String.class, null)); params.put("shortConnectionString", JsonUtil.getJsonValue(app, "short_connection_string", String.class)); params.put("techMatrixId", JsonUtil.getJsonValue(app, "techMatrixId", Integer.class, null)); params.put("parentAppId", JsonUtil.getJsonValue(app, "parent_app_id", Integer.class, null)); params.put("appStatus", JsonUtil.getJsonValue(app, "app_status", String.class, null)); params.put("isLogical", ((boolean) JsonUtil.getJsonValue(app, "is_logical", Boolean.class, false) ? "Y" : "N")); if (isInsert) { JdbcUtil.wherehowsNamedJdbcTemplate.update(INSERT_NEW_APP, params); } else { JdbcUtil.wherehowsNamedJdbcTemplate.update(UPDATE_APP, params); } }
public static Result list() { try { List<Allocation> objects = Allocation.getList(); JsonNode jsonObjects = Allocation.jsonListSerialization(objects); if (jsonObjects.isArray()) { int i = 0; for (JsonNode object : jsonObjects) { ((ObjectNode)object).put("courseSession",objects.get(i).getCourseSession().jsonSerialization()); i++; } } return ok(jsonObjects); }catch(Exception e) { appLogger.error("Error listing objects",e); return internalServerError("Error listing objects"); } }
@Override public JFieldVar apply(String nodeName, JsonNode node, JFieldVar field, Schema currentSchema) { if (ruleFactory.getGenerationConfig().isIncludeJsr303Annotations() && (node.has("minLength") || node.has("maxLength"))) { JAnnotationUse annotation = field.annotate(Size.class); if (node.has("minLength")) { annotation.param("min", node.get("minLength").asInt()); } if (node.has("maxLength")) { annotation.param("max", node.get("maxLength").asInt()); } } return field; }
protected static void validateJsonStructure(JsonNode expectedNode, JsonNode actualNode) { Set<String> expectedFields = new HashSet<>(); Iterator<String> fieldsIterator = expectedNode.fieldNames(); while (fieldsIterator.hasNext()) { expectedFields.add(fieldsIterator.next()); } Set<String> actualFields = new HashSet<>(); fieldsIterator = actualNode.fieldNames(); while (fieldsIterator.hasNext()) { actualFields.add(fieldsIterator.next()); } if (!expectedFields.containsAll(actualFields) || !actualFields.containsAll(expectedFields)) { throw new DataValidationException("Provided json structure is different from stored one '" + actualNode + "'!"); } for (String field : actualFields) { if (!actualNode.get(field).isTextual()) { throw new DataValidationException("Provided json structure can't contain non-text values '" + actualNode + "'!"); } } }
public static Result create() { // Get the form from the request Form<Instructor> form = Form.form(Instructor.class,Instructor.creation.class).bindFromRequest(); // Validate errors if(form.hasErrors()) { return badRequest(form.errorsAsJson()); } // Get the object from the form Instructor object = form.get(); // Create the object in db Ebean.beginTransaction(); try { Instructor.create(object); JsonNode jsonObject = object.jsonSerialization(); Ebean.commitTransaction(); return created(jsonObject); } catch (Exception e) { appLogger.error(Messages.get("Error creating object"), e); return internalServerError("Error creating object"); } finally { Ebean.endTransaction(); } }
@Test public void should_audit_retrieval() throws Exception { final String url = uploadFileAndReturnSelfUrl(); mvc.perform(get(url) .headers(headers)); final MvcResult auditResponse = mvc.perform(get(url + "/auditEntries") .headers(headers)) .andExpect(status().isOk()) .andReturn(); final JsonNode auditEntries = getAuditEntriesFromResponse(auditResponse); assertThat(auditEntries.size(), is(3)); assertThat(auditEntries.get(2).get("action").asText(), equalTo("READ")); }
@RequestMapping(value = "/{id}", method = RequestMethod.GET) public @ResponseBody JsonNode scriptingLoad(@PathVariable @RequestBody Integer id) throws ServiceException, JsonProcessingException { logger.info("Load"); User user = authentificationUtils.getAuthentificatedUser(); try { Script script = scriptingService.load(id); User user1 = userService.findById(script.getCreationUserId()); ObjectMapper mapper = new ObjectMapper(); JsonNode rootNode = mapper.createObjectNode(); ((ObjectNode) rootNode).put("id", script.getId()); ((ObjectNode) rootNode).put("title", script.getTitle()); ((ObjectNode) rootNode).put("content", script.getContent()); ((ObjectNode) rootNode).put("creation_date", script.getCreationDate().toString()); ((ObjectNode) rootNode).put("creation_user", user1.getFirstName() + " " + user1.getLastName()); return rootNode; } finally { authentificationUtils.allowUser(user); } }
@Test public void testsearchOrgs() { PowerMockito.mockStatic(RequestInterceptor.class); when( RequestInterceptor.verifyRequestData(Mockito.anyObject()) ).thenReturn("{userId} uuiuhcf784508 8y8c79-fhh"); Map<String , Object> requestMap = new HashMap<>(); Map<String , Object> innerMap = new HashMap<>(); innerMap.put(JsonKey.ORGANISATION_ID , "org123"); innerMap.put(JsonKey.STATUS, new BigInteger("1")); requestMap.put(JsonKey.REQUEST , innerMap); String data = mapToJson(requestMap); JsonNode json = Json.parse(data); RequestBuilder req = new RequestBuilder().bodyJson(json).uri("/v1/org/search").method("POST"); req.headers(headerMap); Result result = route(req); assertEquals(200, result.status()); }
@Override public Flux<JsonNode> apply(final Flux<ServerSentEvent<JsonNode>> aFlux) { return aFlux.filter(evt -> evt.data().isPresent()) .filter(evt -> evt.event() .map(evtType -> "data".equals(evtType) || "patch".equals(evtType) || "error".equals(evtType)) .orElse(FALSE)) .map(new Function<ServerSentEvent<JsonNode>, JsonNode>() { private JsonNode current; @Override public JsonNode apply(final ServerSentEvent<JsonNode> aEvent) { String type = aEvent.event().get(); switch (type) { case "data": current = aEvent.data().get(); break; case "patch": // current = JsonPatch.apply(aEvent.data().get(), current); current = aEvent.data().get(); break; case "error": aEvent.data() .ifPresent(data -> { throw new RuntimeException("received an error! " + data); }); break; default: throw new IllegalArgumentException("Unknown type: " + type); } return current; } }); }
@Override protected GenericOAuth20Profile extractUserProfile(String body) { final GenericOAuth20Profile profile = new GenericOAuth20Profile(); if (attributesDefinition != null) { profile.setAttributesDefinition(attributesDefinition); } final JsonNode json = JsonHelper.getFirstNode(body); if (json != null) { profile.setId(JsonHelper.getElement(json, "id")); for (final String attribute : profile.getAttributesDefinition().getPrimaryAttributes()) { profile.addAttribute(attribute, JsonHelper.getElement(json, attribute)); } } return profile; }
@Test public void serializeWidthCategoryStems_resultJsonHasWidth() throws IOException { //when CategoryStems categoryStems = new CategoryStems(); categoryStems.setWidth(11f); categoryStemsSerializer.serialize(categoryStems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); //then JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("width")).isTrue(); Assertions.assertThat(actualObj.get("width").asInt()).isEqualTo(11); }
private static String firstToLower(String name) { if (name.equals(JsonNode.class.getSimpleName())) { return "json"; } if (name.equals(ObjectNode.class.getSimpleName())) { return "json.object"; } if (name.equals(ArrayNode.class.getSimpleName())) { return "json.array"; } if (name.equals("UUID")) { return "uuid"; } return Character.toLowerCase(name.charAt(0)) + name.substring(1); }
public static int calculateList(JsonNode node) { int count = 0; Iterator<JsonNode> arrayIterator = node.elements(); while (arrayIterator.hasNext()) { JsonNode element = arrayIterator.next(); if (element.isArray()) { count += calculateList(element); } else if (element.isContainerNode()) { count += calculateDict(element); } } return count; }
@ApiAction public Result getView(String name) throws Exception { ListView obj = imp.getView(name); obj.validate(); JsonNode result = mapper.valueToTree(obj); return ok(result); }
private JsonNode createArray(JsonNode current) { if (ObjectNode.class.isInstance(current)) return ObjectNode.class.cast(current).putArray(fieldName); else if (ArrayNode.class.isInstance(current)) return ArrayNode.class.cast(current).addArray(); else return JsonNodeFactory.instance.arrayNode(); }
@Test public void handle_UnmarshallerReturnsException_WithRequestId() throws Exception { httpResponse.setStatusCode(500); httpResponse.addHeader(HttpResponseHandler.X_AMZN_REQUEST_ID_HEADER, "1234"); expectUnmarshallerMatches(); when(unmarshaller.unmarshall((JsonNode) anyObject())) .thenReturn(new CustomException("error")); AmazonServiceException ase = responseHandler.handle(httpResponse); assertEquals("1234", ase.getRequestId()); }
private static JsonNode parseJsonContent(byte[] rawJsonContent, ObjectMapper mapper) { if (rawJsonContent == null || rawJsonContent.length == 0) { // Note: behavior of mapper.readTree changed in 2.9 so we need to explicitly // check for an empty input and return an empty object or else the return // value will be null: // https://github.com/FasterXML/jackson-databind/issues/1406 return mapper.createObjectNode(); } try { return mapper.readTree(rawJsonContent); } catch (Exception e) { LOG.info("Unable to parse HTTP response content", e); return mapper.createObjectNode(); } }
@Test public void serializeTableDisplay_resultJsonHasType() throws IOException{ //when JsonNode actualObj = serializeTableDisplay(); //then Assertions.assertThat(actualObj.get("type").asText()).isEqualTo("TableDisplay"); }
@Override public CommitMessageDto deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { final JsonNode jsonNode = p.readValueAsTree(); final JsonNode summary = jsonNode.get("summary"); if (summary == null || summary.textValue() == null) { ctxt.reportInputMismatch(CommitMessageDto.class, "commit message should have a summary."); // should never reach here throw new Error(); } final String detail = jsonNode.get("detail") == null ? "" : jsonNode.get("detail").textValue(); final JsonNode markupNode = jsonNode.get("markup"); final Markup markup = Markup.parse(markupNode == null ? "unknown" : markupNode.textValue()); return new CommitMessageDto(summary.textValue(), detail, markup); }
@Override public <X> ValueBinder<X> getBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) { return new BasicBinder<X>(javaTypeDescriptor, this) { @Override protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options) throws SQLException { st.setObject(index, javaTypeDescriptor.unwrap(value, JsonNode.class, options), getSqlType()); } }; }
private Set<String> extractIds(ObjectNode payload) { ArrayNode array = (ArrayNode) payload.path(IDS); if (array == null || array.size() == 0) { return Collections.emptySet(); } Set<String> ids = new HashSet<>(); for (JsonNode node : array) { ids.add(node.asText()); } return ids; }
private JsonNode readConnectionMetadata(String metadata){ try { return mapper.readValue(metadata, JsonNode.class); } catch (IOException e) { throw new IllegalStateException("Could not read metadata from client"); } }
private ObjectNode requireObjectField(final JsonNode node, final String fieldName) { JsonNode value = requireField(node, fieldName); if (value.isObject()) { return (ObjectNode)value; } throw new RuntimeException("Value of JSON key/field \"" + fieldName + "\" is required to be an object."); }