Example usage for javax.json Json createReader

List of usage examples for javax.json Json createReader

Introduction

In this page you can find the example usage for javax.json Json createReader.

Prototype

public static JsonReader createReader(InputStream in) 

Source Link

Document

Creates a JSON reader from a byte stream.

Usage

From source file:com.adobe.cq.wcm.core.components.internal.models.v1.ImageImplTest.java

protected void compareJSON(String expectedJson, String json) {
    JsonReader expected = Json.createReader(new StringReader(expectedJson));
    JsonReader actual = Json.createReader(new StringReader(json));
    assertEquals(expected.read(), actual.read());
}

From source file:nl.nn.adapterframework.pipes.Json2XmlValidator.java

protected PipeRunResult alignJson(String messageToValidate, IPipeLineSession session, boolean responseMode)
        throws PipeRunException, XmlValidatorException {

    ValidationContext context;//from   w  w  w. j av a  2  s  .c o m
    ValidatorHandler validatorHandler;
    try {
        context = validator.createValidationContext(session, getRootValidations(responseMode),
                getInvalidRootNamespaces());
        validatorHandler = validator.getValidatorHandler(session, context);
    } catch (ConfigurationException e) {
        throw new PipeRunException(this, "Cannot create ValidationContext", e);
    }
    String resultEvent;
    String out = null;
    try {
        Json2Xml aligner = new Json2Xml(validatorHandler, context.getXsModels(), isCompactJsonArrays(),
                getMessageRoot(responseMode), isStrictJsonArraySyntax());
        if (StringUtils.isNotEmpty(getTargetNamespace())) {
            aligner.setTargetNamespace(getTargetNamespace());
        }
        aligner.setDeepSearch(isDeepSearch());
        aligner.setErrorHandler(context.getErrorHandler());
        aligner.setFailOnWildcards(isFailOnWildcards());
        ParameterList parameterList = getParameterList();
        if (parameterList != null) {
            ParameterResolutionContext prc = new ParameterResolutionContext(messageToValidate, session,
                    isNamespaceAware());
            Map<String, Object> parametervalues = null;
            parametervalues = prc.getValueMap(parameterList);
            aligner.setOverrideValues(parametervalues);
        }
        JsonStructure jsonStructure = Json.createReader(new StringReader(messageToValidate)).read();

        if (getOutputFormat(session, responseMode).equalsIgnoreCase(FORMAT_JSON)) {
            Xml2Json xml2json = new Xml2Json(aligner, isCompactJsonArrays(), !isJsonWithRootElements());
            aligner.setContentHandler(xml2json);
            aligner.startParse(jsonStructure);
            out = xml2json.toString();
        } else {
            Source source = aligner.asSource(jsonStructure);
            out = XmlUtils.source2String(source, isProduceNamespaceLessXml());
        }
    } catch (Exception e) {
        resultEvent = validator.finalizeValidation(context, session, e);
    }
    resultEvent = validator.finalizeValidation(context, session, null);
    PipeForward forward = determineForward(resultEvent, session, responseMode);
    PipeRunResult result = new PipeRunResult(forward, out);
    return result;
}

From source file:org.trellisldp.http.MultipartUploader.java

/**
 * Create a binary from a collection of uploaded parts
 * @param partition the partition/*www .ja v a 2s  . co  m*/
 * @param id the identifier
 * @param input the input value
 * @return a response
 *
 * <p>Note: The structure should be like this:</p>
 * <pre>{
 *   "1": "somehash",
 *   "2": "otherhash",
 *   "3": "anotherhash"
 * }</pre>
 */
@POST
@Timed
@Consumes("application/json")
public Response createBinary(@PathParam("partition") final String partition, @PathParam("id") final String id,
        final InputStream input) {

    final JsonReader reader = Json.createReader(input);
    final JsonObject obj = reader.readObject();
    reader.close();
    final Map<Integer, String> partDigests = obj.keySet().stream()
            .collect(toMap(Integer::parseInt, obj::getString));

    return binaryService.getResolverForPartition(partition)
            .filter(BinaryService.Resolver::supportsMultipartUpload).filter(svc -> svc.uploadSessionExists(id))
            .map(svc -> svc.completeUpload(id, partDigests)).map(upload -> {
                try (final TrellisDataset dataset = TrellisDataset.createDataset()) {
                    final IRI identifier = rdf.createIRI(TRELLIS_PREFIX + upload.getPath());

                    // Add Audit quads
                    audit.creation(identifier, upload.getSession()).stream()
                            .map(skolemizeQuads(resourceService, upload.getBaseUrl()))
                            .forEachOrdered(dataset::add);
                    dataset.add(rdf.createQuad(PreferServerManaged, identifier, type, NonRDFSource));
                    dataset.add(rdf.createQuad(PreferServerManaged, identifier, DC.hasPart,
                            upload.getBinary().getIdentifier()));
                    dataset.add(rdf.createQuad(PreferServerManaged, upload.getBinary().getIdentifier(),
                            DC.format, rdf.createLiteral(
                                    upload.getBinary().getMimeType().orElse(APPLICATION_OCTET_STREAM))));
                    upload.getBinary().getSize()
                            .ifPresent(size -> dataset
                                    .add(rdf.createQuad(PreferServerManaged, upload.getBinary().getIdentifier(),
                                            DC.extent, rdf.createLiteral(size.toString(), XSD.long_))));

                    if (resourceService.put(identifier, dataset.asDataset())) {
                        return created(create(upload.getBaseUrl() + upload.getPath())).build();
                    }
                }
                LOGGER.error("Could not persist data");
                return serverError().entity("Could not persist data internally").build();
            }).orElseThrow(NotFoundException::new);
}

From source file:org.jboss.as.test.integration.logging.formatters.JsonFormatterTestCase.java

@Test
public void testStructuredException() throws Exception {
    configure(Collections.emptyMap(), Collections.emptyMap(), false);

    // Change the exception-output-type
    executeOperation(//from w ww.  j  a  v a 2  s  . c o  m
            Operations.createWriteAttributeOperation(FORMATTER_ADDRESS, "exception-output-type", "detailed"));

    final String msg = "Logging test: JsonFormatterTestCase.testNoExceptions";
    int statusCode = getResponse(msg,
            Collections.singletonMap(LoggingServiceActivator.LOG_EXCEPTION_KEY, "true"));
    Assert.assertTrue("Invalid response statusCode: " + statusCode, statusCode == HttpStatus.SC_OK);

    final List<String> expectedKeys = createDefaultKeys();
    expectedKeys.add("exception");

    for (String s : Files.readAllLines(logFile, StandardCharsets.UTF_8)) {
        if (s.trim().isEmpty())
            continue;
        try (JsonReader reader = Json.createReader(new StringReader(s))) {
            final JsonObject json = reader.readObject();

            validateDefault(json, expectedKeys, msg);
            validateStackTrace(json, false, true);
        }
    }
}

From source file:io.hops.hopsworks.common.util.WebCommunication.java

private String execute(String path, String hostAddress, String agentPassword, String cluster, String group,
        String service, String command, String[] params) throws Exception {
    String url = createUrl(path, hostAddress, cluster, group, service, command);
    String optionsAndParams = "";
    for (String param : params) {
        optionsAndParams += optionsAndParams.isEmpty() ? param : " " + param;
    }//  ww  w . j  ava2  s  .c o  m
    Response response = postWebResource(url, agentPassword, optionsAndParams);
    int code = response.getStatus();
    Family res = Response.Status.Family.familyOf(code);
    if (res == Response.Status.Family.SUCCESSFUL) {
        String responseString = response.readEntity(String.class);
        if (path.equalsIgnoreCase("execute/continue")) {
            JsonObject json = Json.createReader(response.readEntity(Reader.class)).readObject();
            responseString = json.getString("before");
        }
        return FormatUtils.stdoutToHtml(responseString);
    }
    throw new RuntimeException("Did not succeed to execute command.");
}

From source file:org.ocelotds.integration.AbstractOcelotTest.java

/**
 * Becareful result is not unmarshalled//from w  ww  .  j  a va2  s . c o m
 *
 * @param json
 * @return
 */
protected static MessageToClient mtcFromJson(String json) {
    try (JsonReader reader = Json.createReader(new StringReader(json))) {
        JsonObject root = reader.readObject();
        MessageToClient message = new MessageToClient();
        message.setId(root.getString(Constants.Message.ID));
        message.setTime(root.getInt(Constants.Message.TIME));
        message.setType(MessageType.valueOf(root.getString(Constants.Message.TYPE)));
        message.setDeadline(root.getInt(Constants.Message.DEADLINE));
        if (null != message.getType()) {
            switch (message.getType()) {
            case FAULT:
                JsonObject faultJs = root.getJsonObject(Constants.Message.RESPONSE);
                Fault f = Fault.createFromJson(faultJs.toString());
                message.setFault(f);
                break;
            case MESSAGE:
                message.setResult("" + root.get(Constants.Message.RESPONSE));
                message.setType(MessageType.MESSAGE);
                break;
            case CONSTRAINT:
                JsonArray result = root.getJsonArray(Constants.Message.RESPONSE);
                List<ConstraintViolation> list = new ArrayList<>();
                for (JsonValue jsonValue : result) {
                    list.add(getJava(ConstraintViolation.class, ((JsonObject) jsonValue).toString()));
                }
                message.setConstraints(list.toArray(new ConstraintViolation[] {}));
                break;
            default:
                message.setResult("" + root.get(Constants.Message.RESPONSE));
                break;
            }
        }
        return message;
    }
}

From source file:edu.harvard.hms.dbmi.bd2k.irct.ri.exac.EXACResourceImplementation.java

@Override
public Result runQuery(SecureSession session, Query qep, Result result) throws ResourceInterfaceException {
    // TODO Auto-generated method stub
    HttpClient client = createClient(session);
    result.setResultStatus(ResultStatus.CREATED);

    // Check Clause
    if (qep.getClauses().size() != 1) {
        result.setResultStatus(ResultStatus.ERROR);
        result.setMessage("Wrong number of clauses");
        return result;
    }/*  w  ww.  j  av  a 2 s.co m*/
    ClauseAbstract clause = qep.getClauses().values().iterator().next();

    if (!(clause instanceof WhereClause)) {
        result.setResultStatus(ResultStatus.ERROR);
        result.setMessage("Clause is not a where Clause");
        return result;
    }

    WhereClause whereClause = (WhereClause) clause;
    // Create Query
    String urlString = null;

    // BY ENSEMBL
    if (whereClause.getPredicateType().getName().equals("ENSEMBL")) {
        urlString = resourceURL + "/rest" + getResourcePathFromPUI(whereClause.getField().getPui()) + "/"
                + whereClause.getStringValues().get("ENSEMBLID");

    } else if (whereClause.getPredicateType().getName().equals("QUERY")) {
        // BY QUERY
        String[] resourcePath = getResourcePathFromPUI(whereClause.getField().getPui()).split("/");
        String service = "";
        if (resourcePath.length >= 3) {
            service = "&service=" + resourcePath[2];
        }

        urlString = resourceURL + "/rest/awesome?query=" + whereClause.getStringValues().get("QUERY") + service;
    } else if (whereClause.getPredicateType().getName().equals("REGION")) {
        // BY REGION
        urlString = resourceURL + "/rest" + getResourcePathFromPUI(whereClause.getField().getPui()) + "/"
                + whereClause.getStringValues().get("CHROMOSOME") + "-"
                + whereClause.getStringValues().get("START");
        if (whereClause.getStringValues().containsKey("STOP")) {
            urlString += "-" + whereClause.getStringValues().get("STOP");
        }

    } else if (whereClause.getPredicateType().getName().equals("VARIANT")) {
        // BY VARIANT
        urlString = resourceURL + "/rest" + getResourcePathFromPUI(whereClause.getField().getPui()) + "/"
                + whereClause.getStringValues().get("CHROMOSOME") + "-"
                + whereClause.getStringValues().get("POSITION") + "-"
                + whereClause.getStringValues().get("REFERENCE") + "-"
                + whereClause.getStringValues().get("VARIANT");
    }
    // Run Query
    if (urlString == null) {
        result.setResultStatus(ResultStatus.ERROR);
        result.setMessage("Unknown predicate");
        return result;
    }

    HttpGet get = new HttpGet(urlString);
    try {
        HttpResponse response = client.execute(get);
        JsonReader reader = Json.createReader(response.getEntity().getContent());
        JsonStructure results = reader.read();
        if (results.getValueType().equals(ValueType.ARRAY)) {
            result = convertJsonArrayToResultSet((JsonArray) results, result);
        } else {
            result = convertJsonObjectToResultSet((JsonObject) results, result);
        }
        reader.close();
        result.setResultStatus(ResultStatus.COMPLETE);
    } catch (IOException e) {
        result.setResultStatus(ResultStatus.ERROR);
        result.setMessage(e.getMessage());
    }

    // Format Results

    return result;
}

From source file:fr.ortolang.diffusion.runtime.engine.task.ImportReferentialEntityTask.java

private String extractField(String jsonContent, String fieldName) {
    String fieldValue = null;/*from  w w  w .  jav a  2s. c  om*/
    StringReader reader = new StringReader(jsonContent);
    JsonReader jsonReader = Json.createReader(reader);
    try {
        JsonObject jsonObj = jsonReader.readObject();
        fieldValue = jsonObj.getString(fieldName);
    } catch (IllegalStateException | NullPointerException | ClassCastException | JsonException e) {
        LOGGER.log(Level.WARNING, "No property '" + fieldName + "' in json object", e);
    } finally {
        jsonReader.close();
        reader.close();
    }

    return fieldValue;
}

From source file:fr.ortolang.diffusion.client.cmd.CheckBagCommand.java

private int parseACLLevel(Path aclFile) throws IOException {
    JsonReader reader = Json.createReader(Files.newInputStream(aclFile));
    String name = reader.readObject().getString("template");
    return Template.findTemplateByName(name).getLevel();
}

From source file:org.jboss.as.test.integration.logging.formatters.JsonFormatterTestCase.java

@Test
public void testDateFormat() throws Exception {
    configure(Collections.emptyMap(), Collections.emptyMap(), false);

    final String dateFormat = "yyyy-MM-dd'T'HH:mm:ssSSSZ";
    final String timezone = "GMT";

    // Change the date format and time zone
    final CompositeOperationBuilder builder = CompositeOperationBuilder.create();
    builder.addStep(Operations.createWriteAttributeOperation(FORMATTER_ADDRESS, "date-format", dateFormat));
    builder.addStep(Operations.createWriteAttributeOperation(FORMATTER_ADDRESS, "zone-id", timezone));
    executeOperation(builder.build());/*w  w  w  . j  a v a  2 s . com*/

    final String msg = "Logging test: JsonFormatterTestCase.testNoExceptions";
    int statusCode = getResponse(msg,
            Collections.singletonMap(LoggingServiceActivator.LOG_EXCEPTION_KEY, "false"));
    Assert.assertTrue("Invalid response statusCode: " + statusCode, statusCode == HttpStatus.SC_OK);

    final List<String> expectedKeys = createDefaultKeys();

    for (String s : Files.readAllLines(logFile, StandardCharsets.UTF_8)) {
        if (s.trim().isEmpty())
            continue;
        try (JsonReader reader = Json.createReader(new StringReader(s))) {
            final JsonObject json = reader.readObject();

            validateDefault(json, expectedKeys, msg);
            validateStackTrace(json, false, false);

            // Validate the date format is correct. We don't want to validate the specific date, only that it's
            // parsable.
            final String jsonDate = json.getString("timestamp");
            // If the date is not parsable an exception should be thrown
            try {
                DateTimeFormatter.ofPattern(dateFormat, Locale.ROOT).withZone(ZoneId.of(timezone))
                        .parse(jsonDate);
            } catch (Exception e) {
                Assert.fail(String.format("Failed to parse %s with pattern %s and zone %s: %s", jsonDate,
                        dateFormat, timezone, e.getMessage()));
            }
        }
    }
}