Example usage for com.fasterxml.jackson.core JsonFactory JsonFactory

List of usage examples for com.fasterxml.jackson.core JsonFactory JsonFactory

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.core.*
  5. JsonFactory
  6. JsonFactory

Introduction

In this page you can find the example usage for com.fasterxml.jackson.core JsonFactory JsonFactory.

Prototype

public JsonFactory()

Source Link

Document

Default constructor used to create factory instances.

Usage

From source file:org.apache.drill.exec.store.parquet.metadata.Metadata.java

private void writeFile(ParquetTableMetadataDirs parquetTableMetadataDirs, Path p, FileSystem fs)
        throws IOException {
    JsonFactory jsonFactory = new JsonFactory();
    jsonFactory.configure(Feature.AUTO_CLOSE_TARGET, false);
    jsonFactory.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, false);
    ObjectMapper mapper = new ObjectMapper(jsonFactory);
    SimpleModule module = new SimpleModule();
    mapper.registerModule(module);//from w  w w.  j a  va  2  s  .  c o m
    FSDataOutputStream os = fs.create(p);
    mapper.writerWithDefaultPrettyPrinter().writeValue(os, parquetTableMetadataDirs);
    os.flush();
    os.close();
}

From source file:com.comcast.cdn.traffic_control.traffic_router.core.external.RouterTest.java

@Test
public void itDoesUseLocationFormatResponse() throws IOException, InterruptedException {
    HttpGet httpGet = new HttpGet(
            "http://localhost:" + routerHttpPort + "/stuff?fakeClientIpAddress=12.34.56.78&format=json");
    httpGet.addHeader("Host", "tr." + deliveryServiceId + ".bar");
    CloseableHttpResponse response = null;

    try {//from  w w  w. j ava  2  s .  com
        response = httpClient.execute(httpGet);
        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));

        HttpEntity entity = response.getEntity();
        ObjectMapper objectMapper = new ObjectMapper(new JsonFactory());

        assertThat(entity.getContent(), not(nullValue()));
        System.out.println(entity.getContent());

        JsonNode json = objectMapper.readTree(entity.getContent());
        System.out.println(json);

        assertThat(json.has("location"), equalTo(true));
        assertThat(json.get("location").asText(), isIn(validLocations));
        assertThat(json.get("location").asText(), Matchers.startsWith("http://"));
    } finally {
        if (response != null)
            response.close();
    }
}

From source file:org.apache.cxf.cwiki.SiteExporter.java

private String renderPage(AbstractPage p) throws ParserConfigurationException, IOException {
    ContentResource content = getContentResource();
    InputStream ins = content.getContentById(p.getId(), null, null, "body.export_view")
            .readEntity(InputStream.class);

    JsonParser parser = new JsonFactory().createParser(ins);
    JsonToken tok = parser.nextToken();//from   ww  w. j a  va2 s .c o  m
    boolean inExportView = false;
    while (tok != null) {
        if (tok == JsonToken.FIELD_NAME) {
            if (parser.getCurrentName().equals("export_view")) {
                inExportView = true;
            }
        } else if (tok == JsonToken.VALUE_STRING && inExportView && parser.getCurrentName().equals("value")) {
            return "<div id='ConfluenceContent'>" + parser.getText() + "</div>";
        }
        tok = parser.nextToken();
    }
    System.out.println("No text for page \"" + p.getTitle() + "\"");
    return "";
}

From source file:edu.cmu.cs.lti.discoursedb.github.converter.GithubConverterService.java

public void addCrossrefs(String refinfo, String source, Discourse discourse, User actor) {
    if (refinfo.length() == 0) {
        return;// w w  w.j av  a 2s  .  co m
    }
    try {
        JsonNode node = new ObjectMapper().readValue(new JsonFactory().createParser(refinfo), JsonNode.class);
        for (JsonNode reference : node) {
            JsonNode parts = reference.get("parts");
            String owner = parts.get(0).toString();
            String project = parts.get(1).toString();
            String issueNumString = parts.get(2).toString().replaceAll("[^0-9]+", "");
            String rev = parts.get(3).toString();

            long issuenum = Long.parseLong(issueNumString);

            String issueIdentifier = GithubConverterUtil.standardIssueIdentifier(owner + "/" + project,
                    issuenum);
            DiscoursePart issueDP = getDiscoursePart(discourse, issueIdentifier,
                    DiscoursePartTypes.GITHUB_ISSUE);
            DiscoursePartInteraction dpi = userService.createDiscoursePartInteraction(actor, issueDP,
                    DiscoursePartInteractionTypes.REFER);

            AnnotationInstance crossref = annotationService.createTypedAnnotation("CrossrefFrom");
            annotationService.addAnnotation(dpi, crossref);
            annotationService.addFeature(crossref, annotationService.createTypedFeature(source, "Source"));
        }
    } catch (JsonProcessingException je) {
        logger.error("Could not parse " + refinfo + " from " + source + ": " + je.getMessage());
    } catch (IOException e) {
        logger.error("Could not parse " + refinfo + " from " + source + ": " + e.getMessage());
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

From source file:org.hexlogic.model.DockerNode.java

@VsoMethod(showInApi = true, name = "pullImage", description = "Pull the image matching the given string from the docker hub repository, saving it on the docker host.")
public String pullImage(String imageName) throws Exception {
    log.debug("Pulling image '" + imageName + "'...");

    @SuppressWarnings("rawtypes")
    MappingIterator<Map> it = null;
    try {/*from www  .j a  va2 s .  co m*/
        configureNode();
        DockerClient dockerClient = DockerClientBuilder.getInstance(config).build();
        log.debug("Starting pull operation...");

        /*
         * We will check the final result by comparing the initial image id, which is the first ID provided by the stream such as:
         * 
         * {status=Pulling image (latest) from dockerfile/nodejs, progressDetail={}, id=406eb4a4dcad}
         * 
         * to the image id of the last entity which owns id AND status which will look something like:
         * {status=Download complete, progressDetail={}, id=406eb4a4dcad}
         * 
         * If both IDs match, we know that the latest layer is the same as the requested image layer.
         * So the next step is to compare the download status of that layer
         */
        String firstId = null;
        String lastId = "";
        String lastStatus = "undefined";

        /*
         * In addition to the download status of the layer, we provide additional information about how the process went by
         * returning information to the user using the last entity which has no id and only a status, which looks like this:
         * {status=Status: Image is up to date for dockerfile/nodejs}
         * or
         * {status=Status: Downloaded newer image for dockerfile/nodejs}
         * or
         * {status=Repository dockerfile/nodejs already being pulled by another client. Waiting.}
         */
        String finalStatus = "undefined";

        for (it = new ObjectMapper().readValues(
                new JsonFactory().createJsonParser(dockerClient.pullImageCmd(imageName).exec()), Map.class); it
                        .hasNext();) {
            Map<?, ?> element = it.next();
            String id = "";
            String status = "";
            String progress = "";

            // info OUTPUT
            // log.debug("info: " + element);

            try {
                id = element.get("id").toString();
            } catch (NullPointerException e) {/* catch exception if key was not found */
            }
            try {
                status = element.get("status").toString();
            } catch (NullPointerException e) {/* catch exception if key was not found */
            }
            try {
                progress = element.get("progress").toString();
            } catch (NullPointerException e) {/* catch exception if key was not found */
            }

            // if the key was found and we got some status
            if (!id.isEmpty() && !status.isEmpty()) {
                // remember the first id of the output stream, which is the id of the image we want to pull
                if (firstId == null) {
                    log.debug("Remembering first id: " + id);
                    firstId = id;
                }

                // if the same layer is returned multiple times in a row, don't log everything but just the progress
                if (id.equals(lastId)) {
                    lastId = id;
                    lastStatus = status;
                    if (!progress.isEmpty()) {
                        log.debug("Progress: " + progress);
                    }
                } else {
                    lastId = id;
                    log.debug("Image '" + id + "' status is: " + status + ".");
                    if (!progress.isEmpty()) {
                        log.debug("Progress: " + progress);
                    }
                }
            }

            if (!status.isEmpty()) {
                finalStatus = status;
            }
        }

        // TODO find a more robust way to handle downloadStatus and finalStatus
        String downloadStatus = "undefined";
        if (lastId.equals(firstId)) {
            log.debug("Last download layer id does match the requested image id: " + firstId);
            if (StringUtils.containsIgnoreCase(lastStatus, "Download complete")) {
                downloadStatus = "successed";
                log.debug("The requested layer was downloaded successfuly.");
            } else {
                downloadStatus = "failed";
                log.error("The requested layer failed to download.");
                // throw exception in order for the workflow to fail
                throw new IllegalStateException("The requested layer failed to download.");
            }
        }

        // reload images from docker node
        this.reloadImages();
        // update inventory - another way to do this would be to update our ArrayList and call notifyElementDeleted on the image object
        notificationHandler.notifyElementInvalidate(toRef());

        log.debug("Pull operation " + downloadStatus + ". " + finalStatus + ".");
        return "Pull operation " + downloadStatus + ". " + finalStatus + ".";

    } catch (InternalServerErrorException e) {
        // image dosn't exist
        log.error("Error: the image was not found.");
        // Throw error detail message so vCO can display it
        throw new Exception("Error: the image was not found.");
    } catch (Exception e) {
        final StringWriter sw = new StringWriter();
        final PrintWriter pw = new PrintWriter(sw, true);
        e.printStackTrace(pw);

        log.error("Error while pulling image: " + sw.getBuffer().toString());
        // Throw error detail message so vCO can display it
        throw new Exception("Error while pulling image: " + sw.getBuffer().toString());
    } finally {
        if (it != null) {
            log.debug("Closeing pullImage stream...");
            it.close();
            log.debug("Closed pullImage stream.");
        }
    }

}

From source file:org.jmxtrans.embedded.output.CopperEggWriter.java

public String write_tostring(JsonNode json) {
    ObjectMapper mapper = new ObjectMapper();
    StringWriter out = new StringWriter();

    try {//from  ww w  .  j  a v  a  2 s .  com
        JsonFactory fac = new JsonFactory();
        JsonGenerator gen = fac.createJsonGenerator(out);

        // Now write:
        mapper.writeTree(gen, json);
        gen.flush();
        gen.close();
        return out.toString();
    } catch (Exception e) {
        exceptionCounter.incrementAndGet();
        logger.warn("Exception in write_tostring: " + e);
    }
    return (null);
}

From source file:org.canova.api.conf.Configuration.java

/**
 *  Writes out all the parameters and their properties (final and resource) to
 *  the given {@link Writer}/*from ww  w  .  j a v a  2 s  .c  om*/
 *  The format of the output would be
 *  { "properties" : [ {key1,value1,key1.isFinal,key1.resource}, {key2,value2,
 *  key2.isFinal,key2.resource}... ] }
 *  It does not output the parameters of the configuration object which is
 *  loaded from an input stream.
 * @param out the Writer to write to
 * @throws IOException
 */
public static void dumpConfiguration(Configuration conf, Writer out) throws IOException {
    Configuration config = new Configuration(conf, true);
    config.reloadConfiguration();
    JsonFactory dumpFactory = new JsonFactory();
    JsonGenerator dumpGenerator = dumpFactory.createGenerator(out);
    dumpGenerator.writeStartObject();
    dumpGenerator.writeFieldName("properties");
    dumpGenerator.writeStartArray();
    dumpGenerator.flush();
    for (Map.Entry<Object, Object> item : config.getProps().entrySet()) {
        dumpGenerator.writeStartObject();
        dumpGenerator.writeStringField("key", (String) item.getKey());
        dumpGenerator.writeStringField("value", config.get((String) item.getKey()));
        dumpGenerator.writeBooleanField("isFinal", config.finalParameters.contains(item.getKey()));
        dumpGenerator.writeStringField("resource", config.updatingResource.get(item.getKey()));
        dumpGenerator.writeEndObject();
    }
    dumpGenerator.writeEndArray();
    dumpGenerator.writeEndObject();
    dumpGenerator.flush();
}

From source file:com.marklogic.client.functionaltest.BasicJavaClientREST.java

/**
 * Get the expected JSON document//from  ww w.ja v  a  2  s.c o  m
 * @param filename
 * @return
 * @throws JsonParseException
 * @throws IOException
 */
public JsonNode expectedJSONDocument(String filename) throws JsonParseException, IOException {
    // get json document for expected result
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory jfactory = new JsonFactory();
    JsonParser jParser = jfactory
            .createJsonParser(new File("src/test/java/com/marklogic/client/functionaltest/data/" + filename));
    JsonNode expectedDoc = mapper.readTree(jParser);
    return expectedDoc;
}

From source file:com.marklogic.client.functionaltest.BasicJavaClientREST.java

/**
 * Get the expected JSON query option/*from  w  ww .j ava  2 s . c  om*/
 * @param filename
 * @return
 * @throws JsonParseException
 * @throws IOException
 */
public JsonNode expectedJSONQueryOption(String filename) throws JsonParseException, IOException {
    // get json document for expected result
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory jfactory = new JsonFactory();
    JsonParser jParser = jfactory.createJsonParser(
            new File("src/test/java/com/marklogic/client/functionaltest/queryoptions/" + filename));
    JsonNode expectedDoc = mapper.readTree(jParser);
    return expectedDoc;
}

From source file:com.marklogic.client.functionaltest.TestBiTemporal.java

@Test
// Test bitemporal create, update and delete works with a JSON document while passing
// system time. The temporal collection needs to be enabled for lsqt and we have enabled
// automation for lsqt (lsqt will be advanced every second and system time will be set with 
// a lag of 1 second)
public void testSystemTime() throws Exception {

    System.out.println("Inside testSystemTime");
    ConnectedRESTQA.updateTemporalCollectionForLSQT(dbName, temporalLsqtCollectionName, true);

    String docId = "javaSingleJSONDoc.json";

    Calendar firstInsertTime = DatatypeConverter.parseDateTime("2010-01-01T00:00:01");
    insertJSONSingleDocument(temporalLsqtCollectionName, docId, null, null, firstInsertTime);

    // Verify that the document was inserted
    JSONDocumentManager docMgr = readerClient.newJSONDocumentManager();
    JacksonDatabindHandle<ObjectNode> recordHandle = new JacksonDatabindHandle<ObjectNode>(ObjectNode.class);
    DocumentMetadataHandle metadataHandle = new DocumentMetadataHandle();
    docMgr.read(docId, metadataHandle, recordHandle);
    DocumentPage readResults = docMgr.read(docId);

    System.out.println("Number of results = " + readResults.size());
    assertEquals("Wrong number of results", 1, readResults.size());

    DocumentRecord record = readResults.next();
    System.out.println("URI after insert = " + record.getUri());
    assertEquals("Document uri wrong after insert", docId, record.getUri());
    System.out.println("Content = " + recordHandle.toString());

    // Make sure System start time was what was set ("2010-01-01T00:00:01")
    if (record.getFormat() != Format.JSON) {
        assertFalse("Invalid document format: " + record.getFormat(), true);
    } else {/*from w ww. j  av  a 2  s. c  om*/
        JsonFactory factory = new JsonFactory();
        ObjectMapper mapper = new ObjectMapper(factory);
        TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
        };

        HashMap<String, Object> docObject = mapper.readValue(recordHandle.toString(), typeRef);

        @SuppressWarnings("unchecked")
        HashMap<String, Object> validNode = (HashMap<String, Object>) (docObject.get(systemNodeName));

        String systemStartDate = (String) validNode.get(systemStartERIName);
        String systemEndDate = (String) validNode.get(systemEndERIName);
        System.out.println("systemStartDate = " + systemStartDate);
        System.out.println("systemEndDate = " + systemEndDate);

        assertTrue("System start date check failed", (systemStartDate.contains("2010-01-01T00:00:01")));
        assertTrue("System end date check failed", (systemEndDate.contains("9999-12-31T23:59:59")));

        // Validate collections
        Iterator<String> resCollections = metadataHandle.getCollections().iterator();
        while (resCollections.hasNext()) {
            String collection = resCollections.next();
            System.out.println("Collection = " + collection);

            if (!collection.equals(docId) && !collection.equals(insertCollectionName)
                    && !collection.equals(temporalLsqtCollectionName)
                    && !collection.equals(latestCollectionName)) {
                assertFalse("Collection not what is expected: " + collection, true);
            }
        }

        // Validate permissions
        DocumentPermissions permissions = metadataHandle.getPermissions();
        System.out.println("Permissions: " + permissions);

        String actualPermissions = getDocumentPermissionsString(permissions);
        System.out.println("actualPermissions: " + actualPermissions);

        assertTrue("Document permissions difference in size value", actualPermissions.contains("size:3"));

        assertTrue("Document permissions difference in rest-reader permission",
                actualPermissions.contains("rest-reader:[READ]"));
        assertTrue("Document permissions difference in rest-writer permission",
                actualPermissions.contains("rest-writer:[UPDATE]"));
        assertTrue("Document permissions difference in app-user permission",
                (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                        && actualPermissions.contains("UPDATE") && actualPermissions.contains("EXECUTE")));

        // Validate quality
        int quality = metadataHandle.getQuality();
        System.out.println("Quality: " + quality);
        assertEquals(quality, 11);

        validateMetadata(metadataHandle);
    }

    // =============================================================================
    // Check update works
    // =============================================================================
    Calendar updateTime = DatatypeConverter.parseDateTime("2011-01-01T00:00:01");
    updateJSONSingleDocument(temporalLsqtCollectionName, docId, null, updateTime);

    // Verify that the document was updated
    // Make sure there is 1 document in latest collection
    QueryManager queryMgr = readerClient.newQueryManager();
    StructuredQueryBuilder sqb = queryMgr.newStructuredQueryBuilder();
    StructuredQueryDefinition termQuery = sqb.collection(latestCollectionName);
    long start = 1;
    DocumentPage termQueryResults = docMgr.search(termQuery, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 1, termQueryResults.getTotalSize());

    // Document URIs in latest collection must be the same as the one as the
    // original document
    while (termQueryResults.hasNext()) {
        record = termQueryResults.next();

        String uri = record.getUri();
        System.out.println("URI = " + uri);

        if (!uri.equals(docId)) {
            assertFalse("URIs are not what is expected", true);
        }
    }

    // Make sure there are 4 documents in jsonDocId collection
    queryMgr = readerClient.newQueryManager();
    sqb = queryMgr.newStructuredQueryBuilder();
    termQuery = sqb.collection(docId);

    start = 1;
    termQueryResults = docMgr.search(termQuery, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 4, termQueryResults.getTotalSize());

    // Make sure there are 4 documents in temporal collection
    queryMgr = readerClient.newQueryManager();
    sqb = queryMgr.newStructuredQueryBuilder();
    termQuery = sqb.collection(temporalLsqtCollectionName);

    start = 1;
    termQueryResults = docMgr.search(termQuery, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 4, termQueryResults.getTotalSize());

    // Make sure there are 4 documents in total. Use string search for this
    queryMgr = readerClient.newQueryManager();
    StringQueryDefinition stringQD = queryMgr.newStringDefinition();
    stringQD.setCriteria("");

    start = 1;
    docMgr.setMetadataCategories(Metadata.ALL);
    termQueryResults = docMgr.search(stringQD, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 4, termQueryResults.getTotalSize());

    while (termQueryResults.hasNext()) {
        record = termQueryResults.next();
        System.out.println("URI = " + record.getUri());

        metadataHandle = new DocumentMetadataHandle();
        record.getMetadata(metadataHandle);

        if (record.getFormat() != Format.JSON) {
            assertFalse("Format is not JSON: " + Format.JSON, true);
        } else {
            // Make sure that system and valid times are what is expected
            recordHandle = new JacksonDatabindHandle<ObjectNode>(ObjectNode.class);
            record.getContent(recordHandle);
            System.out.println("Content = " + recordHandle.toString());

            JsonFactory factory = new JsonFactory();
            ObjectMapper mapper = new ObjectMapper(factory);
            TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
            };

            HashMap<String, Object> docObject = mapper.readValue(recordHandle.toString(), typeRef);

            @SuppressWarnings("unchecked")
            HashMap<String, Object> systemNode = (HashMap<String, Object>) (docObject.get(systemNodeName));

            String systemStartDate = (String) systemNode.get(systemStartERIName);
            String systemEndDate = (String) systemNode.get(systemEndERIName);
            System.out.println("systemStartDate = " + systemStartDate);
            System.out.println("systemEndDate = " + systemEndDate);

            @SuppressWarnings("unchecked")
            HashMap<String, Object> validNode = (HashMap<String, Object>) (docObject.get(validNodeName));

            String validStartDate = (String) validNode.get(validStartERIName);
            String validEndDate = (String) validNode.get(validEndERIName);
            System.out.println("validStartDate = " + validStartDate);
            System.out.println("validEndDate = " + validEndDate);

            // Permissions
            DocumentPermissions permissions = metadataHandle.getPermissions();
            System.out.println("Permissions: " + permissions);

            String actualPermissions = getDocumentPermissionsString(permissions);
            System.out.println("actualPermissions: " + actualPermissions);

            int quality = metadataHandle.getQuality();
            System.out.println("Quality: " + quality);

            if (validStartDate.contains("2003-01-01T00:00:00")
                    && validEndDate.contains("2008-12-31T23:59:59")) {
                assertTrue("System start date check failed", (systemStartDate.contains("2011-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("9999-12-31T23:59:59")));

                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(updateCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Properties should be empty", metadataHandle.getProperties().isEmpty());

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")));
                assertFalse("Document permissions difference in app-user permission",
                        actualPermissions.contains("EXECUTE"));

                assertEquals(quality, 99);
            }

            if (validStartDate.contains("2001-01-01T00:00:00")
                    && validEndDate.contains("2003-01-01T00:00:00")) {
                assertTrue("System start date check failed", (systemStartDate.contains("2011-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("9999-12-31T23:59:59")));

                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(insertCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Properties should be empty", metadataHandle.getProperties().isEmpty());

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")
                                && actualPermissions.contains("EXECUTE")));

                assertEquals(quality, 11);
            }

            if (validStartDate.contains("2008-12-31T23:59:59")
                    && validEndDate.contains("2011-12-31T23:59:59")) {
                // This is the latest document
                assertTrue("System start date check failed", (systemStartDate.contains("2011-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("9999-12-31T23:59:59")));
                assertTrue("URI should be the doc uri ", record.getUri().equals(docId));

                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(insertCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)
                            && !collection.equals(latestCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")
                                && actualPermissions.contains("EXECUTE")));

                assertEquals(quality, 11);

                validateMetadata(metadataHandle);
            }

            if (validStartDate.contains("2001-01-01T00:00:00")
                    && validEndDate.contains("2011-12-31T23:59:59")) {
                assertTrue("System start date check failed", (systemStartDate.contains("2010-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("2011-01-01T00:00:01")));

                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(insertCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Properties should be empty", metadataHandle.getProperties().isEmpty());

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")
                                && actualPermissions.contains("EXECUTE")));

                assertEquals(quality, 11);
            }
        }
    }

    // =============================================================================
    // Check delete works
    // =============================================================================
    // Delete one of the document
    Calendar deleteTime = DatatypeConverter.parseDateTime("2012-01-01T00:00:01");
    deleteJSONSingleDocument(temporalLsqtCollectionName, docId, null, deleteTime);

    // Make sure there are still 4 documents in docId collection
    queryMgr = readerClient.newQueryManager();
    sqb = queryMgr.newStructuredQueryBuilder();
    termQuery = sqb.collection(docId);

    start = 1;
    termQueryResults = docMgr.search(termQuery, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 4, termQueryResults.getTotalSize());

    // Make sure there is one document with docId uri
    docMgr = readerClient.newJSONDocumentManager();
    readResults = docMgr.read(docId);

    System.out.println("Number of results = " + readResults.size());
    assertEquals("Wrong number of results", 1, readResults.size());

    // Make sure there are no documents in latest collection
    queryMgr = readerClient.newQueryManager();
    sqb = queryMgr.newStructuredQueryBuilder();
    termQuery = sqb.collection(latestCollectionName);

    start = 1;
    termQueryResults = docMgr.search(termQuery, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 0, termQueryResults.getTotalSize());

    // Make sure there are 4 documents in temporal collection
    queryMgr = readerClient.newQueryManager();
    sqb = queryMgr.newStructuredQueryBuilder();
    termQuery = sqb.collection(temporalLsqtCollectionName);

    start = 1;
    docMgr.setMetadataCategories(Metadata.ALL);
    termQueryResults = docMgr.search(termQuery, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 4, termQueryResults.getTotalSize());

    while (termQueryResults.hasNext()) {
        record = termQueryResults.next();
        System.out.println("URI = " + record.getUri());

        metadataHandle = new DocumentMetadataHandle();
        record.getMetadata(metadataHandle);

        if (record.getFormat() != Format.JSON) {
            assertFalse("Format is not JSON: " + Format.JSON, true);
        } else {
            // Make sure that system and valid times are what is expected
            recordHandle = new JacksonDatabindHandle<ObjectNode>(ObjectNode.class);
            record.getContent(recordHandle);
            System.out.println("Content = " + recordHandle.toString());

            JsonFactory factory = new JsonFactory();
            ObjectMapper mapper = new ObjectMapper(factory);
            TypeReference<HashMap<String, Object>> typeRef = new TypeReference<HashMap<String, Object>>() {
            };

            HashMap<String, Object> docObject = mapper.readValue(recordHandle.toString(), typeRef);

            @SuppressWarnings("unchecked")
            HashMap<String, Object> systemNode = (HashMap<String, Object>) (docObject.get(systemNodeName));

            String systemStartDate = (String) systemNode.get(systemStartERIName);
            String systemEndDate = (String) systemNode.get(systemEndERIName);
            System.out.println("systemStartDate = " + systemStartDate);
            System.out.println("systemEndDate = " + systemEndDate);

            @SuppressWarnings("unchecked")
            HashMap<String, Object> validNode = (HashMap<String, Object>) (docObject.get(validNodeName));

            String validStartDate = (String) validNode.get(validStartERIName);
            String validEndDate = (String) validNode.get(validEndERIName);
            System.out.println("validStartDate = " + validStartDate);
            System.out.println("validEndDate = " + validEndDate);

            // Permissions
            DocumentPermissions permissions = metadataHandle.getPermissions();
            System.out.println("Permissions: " + permissions);

            String actualPermissions = getDocumentPermissionsString(permissions);
            System.out.println("actualPermissions: " + actualPermissions);

            int quality = metadataHandle.getQuality();
            System.out.println("Quality: " + quality);

            if (validStartDate.contains("2003-01-01T00:00:00")
                    && validEndDate.contains("2008-12-31T23:59:59")) {
                assertTrue("System start date check failed", (systemStartDate.contains("2011-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("2012-01-01T00:00:01")));

                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(updateCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Properties should be empty", metadataHandle.getProperties().isEmpty());

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")));
                assertFalse("Document permissions difference in app-user permission",
                        actualPermissions.contains("EXECUTE"));

                assertEquals(quality, 99);
            }

            if (validStartDate.contains("2001-01-01T00:00:00")
                    && validEndDate.contains("2003-01-01T00:00:00")) {
                assertTrue("System start date check failed", (systemStartDate.contains("2011-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("2012-01-01T00:00:01")));

                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(insertCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Properties should be empty", metadataHandle.getProperties().isEmpty());

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")
                                && actualPermissions.contains("EXECUTE")));

                assertEquals(quality, 11);
            }

            if (validStartDate.contains("2008-12-31T23:59:59")
                    && validEndDate.contains("2011-12-31T23:59:59")) {
                assertTrue("System start date check failed", (systemStartDate.contains("2011-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("2012-01-01T00:00:01")));

                assertTrue("URI should be the doc uri ", record.getUri().equals(docId));

                // Document should not be in latest collection
                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(insertCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")
                                && actualPermissions.contains("EXECUTE")));

                assertEquals(quality, 11);

                validateMetadata(metadataHandle);
            }

            if (validStartDate.contains("2001-01-01T00:00:00")
                    && validEndDate.contains("2011-12-31T23:59:59")) {
                assertTrue("System start date check failed", (systemStartDate.contains("2010-01-01T00:00:01")));
                assertTrue("System start date check failed", (systemEndDate.contains("2011-01-01T00:00:01")));
                Iterator<String> resCollections = metadataHandle.getCollections().iterator();
                while (resCollections.hasNext()) {
                    String collection = resCollections.next();
                    System.out.println("Collection = " + collection);

                    if (!collection.equals(docId) && !collection.equals(insertCollectionName)
                            && !collection.equals(temporalLsqtCollectionName)) {
                        assertFalse("Collection not what is expected: " + collection, true);
                    }
                }

                assertTrue("Properties should be empty", metadataHandle.getProperties().isEmpty());

                assertTrue("Document permissions difference in size value",
                        actualPermissions.contains("size:3"));

                assertTrue("Document permissions difference in rest-reader permission",
                        actualPermissions.contains("rest-reader:[READ]"));
                assertTrue("Document permissions difference in rest-writer permission",
                        actualPermissions.contains("rest-writer:[UPDATE]"));
                assertTrue("Document permissions difference in app-user permission",
                        (actualPermissions.contains("app-user:[") && actualPermissions.contains("READ")
                                && actualPermissions.contains("UPDATE")
                                && actualPermissions.contains("EXECUTE")));

                assertEquals(quality, 11);
            }
        }
    }

    // Make sure there are 4 documents in total. Use string search for this
    queryMgr = readerClient.newQueryManager();

    start = 1;
    termQueryResults = docMgr.search(stringQD, start);
    System.out.println("Number of results = " + termQueryResults.getTotalSize());
    assertEquals("Wrong number of results", 4, termQueryResults.getTotalSize());
}