@Test public void testBadSendMessage() throws Exception { SendMessageDTO message = new SendMessageDTO(); message.setTo("JonkiPro2"); ObjectMapper mapper = new ObjectMapper(); mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, false); ObjectWriter ow = mapper.writer().withDefaultPrettyPrinter(); String requestJson = ow.writeValueAsString(message); mockMvc .perform(post("/api/v1.0/messages/") .with(user(USERNAME).password(PASSWORD).roles(ROLE)) .contentType(MediaType.APPLICATION_JSON_UTF8_VALUE) .content(requestJson)) .andExpect(status().isBadRequest()); }
public boolean exportStatus(String outputFile) { Repository frozenRepository = this.repository.getSnapshotTo(this.repository.getRoot()); File dumpFile = new File(outputFile); try(FileWriter fw = new FileWriter(dumpFile.getAbsoluteFile()); BufferedWriter bw = new BufferedWriter(fw)) { JsonNodeFactory jsonFactory = new JsonNodeFactory(false); ObjectNode mainNode = jsonFactory.objectNode(); for (ByteArrayWrapper address : frozenRepository.getAccountsKeys()) { if(!address.equals(new ByteArrayWrapper(ZERO_BYTE_ARRAY))) { mainNode.set(Hex.toHexString(address.getData()), createAccountNode(mainNode, address.getData(), frozenRepository)); } } ObjectMapper mapper = new ObjectMapper(); ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter(); bw.write(writer.writeValueAsString(mainNode)); return true; } catch (IOException e) { logger.error(e.getMessage(), e); panicProcessor.panic("dumpstate", e.getMessage()); return false; } }
public void saveProfile() throws IOException { ObjectMapper mapper = new ObjectMapper(); ObjectWriter ow = mapper.writer().withDefaultPrettyPrinter(); ow.writeValue(new File(profileFileName), localClient().getProfile()); }
@Test public void testWriteValueOutputStreamObject() { boolean status = true; String[] stringArray = new String[1]; stringArray[0] = "abc"; new MockUp<ObjectWriter>() { @Mock public void writeValue(OutputStream out, Object value) throws IOException, JsonGenerationException, JsonMappingException { } }; try { StandardObjectWriter.writeValue(outputStream, stringArray); } catch (IOException e) { status = false; } Assert.assertTrue(status); }
@Override public boolean execute(String[] tokens, String line) throws Exception { if (tokens.length < 2) { err.println("Usage: " + syntaxString()); return false; } if (!checkStoreSettings()) return false; StringReader sr = new StringReader(line); while (sr.read() != ' '); JsonParser jp = mjf.createParser(sr); JsonNode keyNode = validateJson(jp); if (keyNode == null) return false; ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter(); out.println("Deleting Key:"); out.println(writer.writeValueAsString(keyNode)); out.println(""); storeClient.delete(keyNode); out.println("Success"); return false; }
public static void write(SecurityAnalysisResult result, Writer writer) throws IOException { Objects.requireNonNull(result); Objects.requireNonNull(writer); ObjectMapper objectMapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.addSerializer(SecurityAnalysisResult.class, new SecurityAnalysisResultSerializer()); module.addSerializer(NetworkMetadata.class, new NetworkMetadataSerializer()); module.addSerializer(PostContingencyResult.class, new PostContingencyResultSerializer()); module.addSerializer(LimitViolationsResult.class, new LimitViolationsResultSerializer()); module.addSerializer(LimitViolation.class, new LimitViolationSerializer()); module.addSerializer(ContingencyElement.class, new ContingencyElementSerializer()); objectMapper.registerModule(module); ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter(); objectWriter.writeValue(writer, result); }
@Override public void close() throws IOException { try { final EncryptedDataContainer encrypted = cipher.doFinal(); super.write(encrypted.getContent()); final String tag = CryptoUtils.byteArrayToString(encrypted.getTag()); final ObjectReader reader = session.getClient().getJSON().getContext(null).readerFor(FileKey.class); final FileKey fileKey = reader.readValue(status.getFilekey().array()); fileKey.setTag(tag); final ObjectWriter writer = session.getClient().getJSON().getContext(null).writerFor(FileKey.class); final ByteArrayOutputStream out = new ByteArrayOutputStream(); writer.writeValue(out, fileKey); status.setFilekey(ByteBuffer.wrap(out.toByteArray())); } catch(CryptoSystemException e) { throw new IOException(e); } finally { super.close(); } }
@Override public String getText(JsonNode jsonNode, int prettyIndent) throws ServiceException { ObjectMapper mapper = new ObjectMapper(); try { ObjectWriter writer; if (prettyIndent > 0) writer = mapper.writer(new JacksonPrettyPrinter(prettyIndent)); else writer = mapper.writer(); return writer.writeValueAsString(jsonNode); } catch (JsonProcessingException ex) { throw new ServiceException(Status.INTERNAL_ERROR, ex.getMessage(), ex); } }
@Override public Void pre(final Transfer.Type type, final Map<Path, TransferStatus> files, final ConnectionCallback callback) throws BackgroundException { try { switch(type) { case download: break; default: if(session.userAccount().isEncryptionEnabled()) { for(Map.Entry<Path, TransferStatus> entry : files.entrySet()) { if(containerService.getContainer(entry.getKey()).getType().contains(Path.Type.vault)) { final TransferStatus status = entry.getValue(); final FileKey fileKey = TripleCryptConverter.toSwaggerFileKey(Crypto.generateFileKey()); final ObjectWriter writer = session.getClient().getJSON().getContext(null).writerFor(FileKey.class); final ByteArrayOutputStream out = new ByteArrayOutputStream(); writer.writeValue(out, fileKey); status.setFilekey(ByteBuffer.wrap(out.toByteArray())); } } } } return null; } catch(IOException e) { throw new DefaultIOExceptionMappingService().map(e); } }
@Override public String getConfiguration() { try { ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter(); return writer.writeValueAsString(currentConfig); } catch (JsonProcessingException e) { logger.error("Error writing configuration to string", e); return e.toString(); } }
protected void writeEmptyHostJsonFile(final ObjectWriter objectWriter) throws IOException { info(""); info(SAVE_HOST_JSON); final File hostJsonFile = Paths.get(getDeploymentStageDirectory(), HOST_JSON).toFile(); writeObjectToFile(objectWriter, new Object(), hostJsonFile); info(SAVE_SUCCESS + hostJsonFile.getAbsolutePath()); }
@Override public HashMap<String, String> getStringMap(Object object) { try { TypeReference<HashMap<String, String>> typeRef = new TypeReference<HashMap<String, String>>() { }; ObjectWriter objectWriter = mapper.writerFor(object.getClass()); return mapper.readValue(objectWriter.writeValueAsString(object), typeRef); } catch (Exception e) { e.printStackTrace(); } return new HashMap<>(); }
@Test public void testJSONGeneratorConfigured() throws IOException { JSONPrettyPrintFilter filter = new JSONPrettyPrintFilter(); ContainerRequest request = ContainerRequestBuilder.from("http://localhost/foo/bar?pretty", "GET").accept("random/media").build(); ContainerResponse response = new ContainerResponse(request, Response.ok().build()); filter.filter(request, response); ObjectWriterModifier modifier = ObjectWriterInjector.get(); assertNotNull(modifier); JsonGenerator g = mock(JsonGenerator.class); modifier.modify(mock(JsonEndpointConfig.class), new MultivaluedHashMap<String, Object>(), new Object(), mock(ObjectWriter.class), g); verify(g).useDefaultPrettyPrinter(); }
@Override public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) { JavaType javaType = mapper.getTypeFactory().constructType(type); ObjectWriter writer = mapper.writerFor(javaType); return new JacksonRequestBodyConverter<>(writer); }
@Override public String getString(Object object) { try { ObjectWriter objectWriter = mapper.writerFor(object.getClass()); return objectWriter.writeValueAsString(object); } catch (Exception e) { e.printStackTrace(); } return ""; }
@Override public boolean execute(String[] tokens, String line) throws Exception { if (tokens.length < 3) { err.println("Usage: " + syntaxString()); return false; } if (!checkStoreSettings()) return false; StringReader sr = new StringReader(line); while (sr.read() != ' '); JsonParser jp = mjf.createParser(sr); JsonNode keyNode = validateJson(jp); if (keyNode == null) return false; JsonNode valueNode = validateJson(jp); if (valueNode == null) return false; ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter(); out.println("Putting Key:"); out.println(writer.writeValueAsString(keyNode)); out.println("\nValue:"); out.println(writer.writeValueAsString(valueNode)); out.flush(); storeClient.put(keyNode, valueNode); out.println("Success"); return false; }
@Test public void parseSimplePlan() throws Exception{ LogicalPlanPersistence lpp = new LogicalPlanPersistence(DEFAULT_SABOT_CONFIG, CLASSPATH_SCAN_RESULT); PhysicalPlanReader reader = new PhysicalPlanReader(DEFAULT_SABOT_CONFIG, CLASSPATH_SCAN_RESULT, lpp, CoordinationProtos.NodeEndpoint.getDefaultInstance(), null, Mockito.mock(SabotContext.class)); ObjectWriter writer = lpp.getMapper().writer(); PhysicalPlan plan = reader.readPhysicalPlan(Files.toString(FileUtils.getResourceAsFile("/physical_test1.json"), Charsets.UTF_8)); String unparse = plan.unparse(writer); }
static byte[] serialize(final Object value) { final ObjectWriter writer = MAPPER.writerFor(value.getClass()); try { return writer.writeValueAsBytes(value); } catch (final JsonProcessingException e) { throw new IllegalArgumentException("Unable to serialize given value: " + value, e); } }
@Override public String toString() { ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter(); try { return ow.writeValueAsString(this); } catch (JsonProcessingException e) { return "Could Not Marshal Object to JSON"; } }
@CsapDoc ( notes = { "Health Check for eman. Alert Level can be used to customize thresholds.", CsapDoc.INDENT + "A configured limit of 100, with alertLevel=1.5 will become 150" } , produces = "plain/txt" ) @RequestMapping ( "/emanStatus" ) public String emanStatus ( @RequestParam ( value = "alertLevel" , required = false , defaultValue = "1.0" ) double alertLevelForFiltering ) { logger.debug( "AlertLevel : {}", alertLevelForFiltering ); String result = "Failure"; try { // check vm connections ObjectNode errorNode = csapApp.buildErrorsForAdminOrAgent( alertLevelForFiltering ); if ( errorNode.size() == 0 ) { result = "Success"; } else { ObjectWriter writer = jacksonMapper.writerWithDefaultPrettyPrinter(); result = "Failure\n" + writer.writeValueAsString( errorNode ); } } catch (Exception e) { logger.error( "Failed: ", e ); } return result; }
private String getErrors(TransformException exception) throws JsonProcessingException { ObjectWriter jsonObjectWriter = new ObjectMapper() .setSerializationInclusion(JsonInclude.Include.NON_NULL) .writer() .withDefaultPrettyPrinter(); return jsonObjectWriter.writeValueAsString(exception.getDetails()); }
/** * Write out the errors to a file. * * @param allErrors The errors to write. * @param outFile The location to write. */ private void writeOutErrors(AllErrors allErrors, Path outFile) { try (Writer writer = Files.newBufferedWriter(outFile)) { ObjectWriter jsonObjectWriter = new ObjectMapper() .setSerializationInclusion(JsonInclude.Include.NON_NULL) .writer() .withDefaultPrettyPrinter(); jsonObjectWriter.writeValue(writer, allErrors); } catch (IOException exception) { DEV_LOG.error("Could not write out error JSON to file", exception); } }
public static void write(LoadFlowResult result, Path jsonFile) { Objects.requireNonNull(result); Objects.requireNonNull(jsonFile); try (OutputStream os = Files.newOutputStream(jsonFile)) { ObjectMapper objectMapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.addSerializer(LoadFlowResult.class, new LoadFlowResultSerializer()); objectMapper.registerModule(module); ObjectWriter writer = objectMapper.writerWithDefaultPrettyPrinter(); writer.writeValue(os, result); } catch (IOException e) { throw new UncheckedIOException(e); } }
/** * Serialize a list of objects with a particular set of attributes * @param view * @return * @throws IOException */ public JsonNode jsonSerialization(Class view) throws IOException { ObjectMapper mapper = new ObjectMapper(); DateFormat myDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS"); mapper.setDateFormat(myDateFormat); mapper.disable(MapperFeature.DEFAULT_VIEW_INCLUSION); ObjectWriter writer = mapper.writerWithView(view); JsonNode response = mapper.readTree(writer.writeValueAsString(this)); return response; }
protected ObjectWriter getWriter(Format format, int prettyIndent) { ObjectMapper mapper = getMapper(format); if (prettyIndent > 0) return mapper.writer(new JacksonPrettyPrinter(prettyIndent)); else return mapper.writer(); }
@Override public ObjectWriter modify(EndpointConfigBase<?> endpointConfigBase, MultivaluedMap<String, Object> multivaluedMap, Object o, ObjectWriter objectWriter, JsonGenerator jsonGenerator) throws IOException { jsonGenerator.useDefaultPrettyPrinter(); return objectWriter; }
/** * Returns an ObjectWriter with the project default settings. * @param features the SerializationFeatures to be enabled, overwriting the project defaults * @return ObjectWriter */ public static ObjectWriter writer(SerializationFeature... features) { if (features.length == 0) { return mapper.writer(); } else if (features.length == 1) { return mapper.writer(features[0]); } else { return mapper.writer(features[0], Arrays.copyOfRange(features, 1, features.length)); } }
private String toJson(Object src) { try { ObjectWriter defaultPrettyPrinter = objectMapper.writerWithDefaultPrettyPrinter(); return defaultPrettyPrinter.writeValueAsString(src); } catch (Exception e) { log.error("Error during converting object to JSON", e); return "{}"; } }
/** Converts a physical plan to a string. (Opposite of {@link #parse}.) */ public String unparse(ObjectWriter writer) { try { return writer.writeValueAsString(this); } catch (JsonProcessingException e) { throw new RuntimeException(e); } }
