How to use

createLiteral

method

in

org.apache.commons.rdf.jena.JenaRDF

/**
 * Get the PROV.endedAtTime quad, wrapped in a Stream
 * @param identifier the identifier
 * @param dataset the dataset
 * @param time the time
 * @return the quad
 */
public static Stream<Quad> endedAtQuad(final IRI identifier, final Dataset dataset, final Instant time) {
  return dataset.stream(of(PreferAudit), identifier, wasGeneratedBy, null)
    .map(Quad::getObject).filter(term -> term instanceof BlankNodeOrIRI)
    .map(term -> (BlankNodeOrIRI) term)
    .map(term -> (Quad) rdf.createQuad(PreferAudit, term, endedAtTime,
        rdf.createLiteral(time.toString(), dateTime))).limit(1);
}

@Override
public CompletionStage<Void> touch(final IRI identifier) {
  final Literal time = rdf.createLiteral(now().toString(), XSD.dateTime);
  return runAsync(() -> {
    try {
      rdfConnection.update(buildUpdateModificationRequest(identifier, time));
    } catch (final Exception ex) {
      throw new RuntimeTrellisException("Could not update data for " + identifier, ex);
    }
  });
}

@Override
public CompletionStage<Void> touch(final IRI identifier) {
  final Literal time = rdf.createLiteral(now().toString(), XSD.dateTime);
  return runAsync(() -> {
    try {
      rdfConnection.update(buildUpdateModificationRequest(identifier, time));
    } catch (final Exception ex) {
      throw new RuntimeTrellisException("Could not update data for " + identifier, ex);
    }
  });
}

private void storeResource(final IRI identifier, final Dataset dataset,
    final Instant eventTime, final OperationType type) {
  final Literal time = rdf.createLiteral(eventTime.toString(), XSD.dateTime);
  try {
    rdfConnection.update(buildUpdateRequest(identifier, time, dataset, type));
  } catch (final Exception ex) {
    throw new RuntimeTrellisException("Could not update data for " + identifier, ex);
  }
}

private void storeResource(final IRI identifier, final Dataset dataset,
    final Instant eventTime, final OperationType type) {
  final Literal time = rdf.createLiteral(eventTime.toString(), XSD.dateTime);
  try {
    rdfConnection.update(buildUpdateRequest(identifier, time, dataset, type));
  } catch (final Exception ex) {
    throw new RuntimeTrellisException("Could not update data for " + identifier, ex);
  }
}

private static JenaDataset buildLdpDataset(final IRI ldpType) {
  final JenaDataset dataset = rdf.createDataset();
  dataset.add(identifier, identifier, RDF.type, SKOS.Concept);
  dataset.add(identifier, identifier, SKOS.prefLabel, rdf.createLiteral("resource"));
  dataset.add(member, member, SKOS.prefLabel, rdf.createLiteral("member resource"));
  dataset.add(Trellis.PreferServerManaged, identifier, RDF.type, ldpType);
  dataset.add(Trellis.PreferServerManaged, identifier, DC.modified, rdf.createLiteral(time, XSD.dateTime));
  dataset.add(Trellis.PreferServerManaged, member, RDF.type, LDP.RDFSource);
  dataset.add(Trellis.PreferServerManaged, member, DC.modified, rdf.createLiteral(time, XSD.dateTime));
  return dataset;
}

@Test
public void testInvalidInbox() {
  final Optional<ConstraintViolation> res = svc.constrainedBy(LDP.RDFSource,
      asGraph("/invalidInbox.ttl", domain + "foo"), domain).findFirst();
  assertTrue(res.isPresent(), "no constraint violation found!");
  res.ifPresent(violation -> {
    assertEquals(Trellis.InvalidRange, violation.getConstraint(), "no InvalidRange constraint!");
    assertTrue(violation.getTriples().contains(rdf.createTriple(rdf.createIRI(domain + "foo"),
            LDP.inbox, rdf.createLiteral("invalid range", "en"))),
        "Triple not found in constraint violation!");
  });
}

@Test
public void testInitializeRoot2() {
  final Instant early = now();
  final JenaDataset dataset = rdf.createDataset();
  dataset.add(Trellis.PreferServerManaged, root, RDF.type, LDP.BasicContainer);
  dataset.add(Trellis.PreferServerManaged, root, DC.modified, rdf.createLiteral(early.toString(), XSD.dateTime));
  final RDFConnection rdfConnection = connect(wrap(dataset.asJenaDatasetGraph()));
  final TriplestoreResourceService svc = new TriplestoreResourceService(rdfConnection);
  svc.initialize();
  final Resource res = svc.get(root).toCompletableFuture().join();
  assertAll("Check resource", checkResource(res, root, LDP.BasicContainer, early));
  assertAll("Check resource stream", checkResourceStream(res, 0L, 0L, 0L, 0L, 0L));
}

@Test
public void testPutLdpRsWithoutBaseUrl() throws Exception {
  final TriplestoreResourceService svc = new TriplestoreResourceService(
      connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
  svc.initialize();
  final Dataset dataset = rdf.createDataset();
  dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("title"));
  dataset.add(Trellis.PreferAudit, rdf.createBlankNode(), RDF.type, AS.Create);
  final Instant later = meanwhile();
  assertDoesNotThrow(() -> allOf(
    svc.create(builder(resource).interactionModel(LDP.RDFSource).container(root).build(), dataset)
      .toCompletableFuture(),
    svc.touch(root).toCompletableFuture()).join(), "Unsuccessful create operation!");
  allOf(
    svc.get(resource).thenAccept(checkResource(later, LDP.RDFSource, 1L, 1L, 0L)).toCompletableFuture(),
    svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture()).join();
}

@Test
public void testPutLdpRs() throws Exception {
  final TriplestoreResourceService svc = new TriplestoreResourceService(
      connect(wrap(rdf.createDataset().asJenaDatasetGraph())));
  svc.initialize();
  final Dataset dataset = rdf.createDataset();
  final BlankNode bnode = rdf.createBlankNode();
  dataset.add(Trellis.PreferUserManaged, resource, DC.title, rdf.createLiteral("title"));
  dataset.add(Trellis.PreferAudit, resource, PROV.wasGeneratedBy, bnode);
  dataset.add(Trellis.PreferAudit, bnode, RDF.type, PROV.Activity);
  dataset.add(Trellis.PreferAudit, bnode, RDF.type, AS.Create);
  final Instant later = meanwhile();
  assertDoesNotThrow(() -> allOf(
    svc.create(builder(resource).interactionModel(LDP.RDFSource).container(root).build(), dataset)
      .toCompletableFuture(),
    svc.touch(root).toCompletableFuture()).join(), "Unsuccessful create operation!");
  allOf(
    svc.get(resource).thenAccept(checkResource(later, LDP.RDFSource, 1L, 3L, 0L)).toCompletableFuture(),
    svc.get(root).thenAccept(checkRoot(later, 1L)).toCompletableFuture()).join();
}

@Test
public void testPartialResource() {
  final JenaDataset dataset = rdf.createDataset();
  dataset.add(Trellis.PreferServerManaged, identifier, DC.modified, rdf.createLiteral(time, XSD.dateTime));
  final TriplestoreResource res = new TriplestoreResource(connect(wrap(dataset.asJenaDatasetGraph())),
      identifier);
  res.fetchData();
  assertFalse(res.exists(), "Unexpected resource!");
}

@Test
public void asGeneralizedQuad() throws Exception {
  final Node s = NodeFactory.createLiteral("Hello");
  final Node p = NodeFactory.createBlankNode();
  final Node o = NodeFactory.createURI("http://example.com/ex");
  final Node g = Quad.defaultGraphIRI;
  final Quad jq = Quad.create(g, s, p, o);
  final JenaQuadLike<RDFTerm> q = jena.asGeneralizedQuad(jq);
  assertEquals(jena.createLiteral("Hello"), q.getSubject());
  assertEquals(jena.asRDFTerm(p), q.getPredicate());
  assertEquals(jena.createIRI("http://example.com/ex"), q.getObject());
  assertFalse(q.getGraphName().isPresent());
}

@Test
public void literalGraph() throws Exception {
  final JenaIRI ex1 = jena.createIRI("http://example.com/ex1");
  final JenaIRI ex2 = jena.createIRI("http://example.com/ex2");
  final JenaIRI ex3 = jena.createIRI("http://example.com/ex3");
  final JenaLiteral lit = jena.createLiteral("Hello");
  final JenaGeneralizedQuadLike q = jena.createGeneralizedQuad(ex1, ex2, ex3, lit);
  assertEquals(ex1, q.getSubject());
  assertEquals(ex2, q.getPredicate());
  assertEquals(ex3, q.getObject());
  assertEquals(lit, q.getGraphName().get()); // it's a literal!
  assertTrue(q.asJenaQuad().getGraph().isLiteral());
}

@Test
public void literalPredicate() throws Exception {
  final JenaIRI ex1 = jena.createIRI("http://example.com/ex1");
  final JenaIRI ex2 = jena.createIRI("http://example.com/ex2");
  final JenaIRI ex3 = jena.createIRI("http://example.com/ex3");
  final JenaLiteral lit = jena.createLiteral("Hello");
  final JenaGeneralizedQuadLike q = jena.createGeneralizedQuad(ex1, lit, ex2, ex3);
  assertEquals(ex1, q.getSubject());
  assertEquals(ex2, q.getObject());
  assertEquals(lit, q.getPredicate()); // it's a literal!
  assertEquals(ex3, q.getGraphName().get());
  assertTrue(q.asJenaQuad().getPredicate().isLiteral());
}

@Test
public void literalSubject() throws Exception {
  final JenaIRI ex1 = jena.createIRI("http://example.com/ex1");
  final JenaIRI ex2 = jena.createIRI("http://example.com/ex2");
  final JenaIRI ex3 = jena.createIRI("http://example.com/ex3");
  final JenaLiteral lit = jena.createLiteral("Hello");
  final JenaGeneralizedQuadLike q = jena.createGeneralizedQuad(lit, ex1, ex2, ex3);
  assertEquals(lit, q.getSubject()); // it's a literal!
  assertEquals(ex1, q.getPredicate());
  assertEquals(ex2, q.getObject());
  assertEquals(ex3, q.getGraphName().get());
  assertTrue(q.asJenaQuad().getSubject().isLiteral());
}

@Test
public void literalPredicate() throws Exception {
  final JenaIRI ex1 = jena.createIRI("http://example.com/ex1");
  final JenaIRI ex2 = jena.createIRI("http://example.com/ex2");
  final JenaLiteral lit = jena.createLiteral("Hello");
  final JenaGeneralizedTripleLike t = jena.createGeneralizedTriple(ex1, lit, ex2);
  assertEquals(ex1, t.getSubject());
  assertEquals(ex2, t.getObject());
  assertEquals(lit, t.getPredicate()); // it's a literal!
  assertTrue(t.asJenaTriple().getPredicate().isLiteral());
}

@Test
public void literalSubject() throws Exception {
  final JenaIRI ex1 = jena.createIRI("http://example.com/ex1");
  final JenaIRI ex2 = jena.createIRI("http://example.com/ex2");
  final JenaLiteral lit = jena.createLiteral("Hello");
  final JenaGeneralizedTripleLike t = jena.createGeneralizedTriple(lit, ex1, ex2);
  assertEquals(lit, t.getSubject()); // it's a literal!
  assertEquals(ex1, t.getPredicate());
  assertEquals(ex2, t.getObject());
  assertTrue(t.asJenaTriple().getSubject().isLiteral());
}

@Test
public void asGeneralizedTriple() throws Exception {
  final Node s = NodeFactory.createLiteral("Hello");
  final Node p = NodeFactory.createBlankNode();
  final Node o = NodeFactory.createURI("http://example.com/ex");
  final Triple jt = Triple.create(s, p, o);
  final JenaTripleLike t = jena.asGeneralizedTriple(jt);
  assertEquals(jena.createLiteral("Hello"), t.getSubject());
  assertEquals(jena.asRDFTerm(p), t.getPredicate());
  assertEquals(jena.createIRI("http://example.com/ex"), t.getObject());
}

@Test
public void literalSubjectDefaultGraphGen() throws Exception {
  final JenaIRI ex1 = jena.createIRI("http://example.com/ex1");
  final JenaIRI ex2 = jena.createIRI("http://example.com/ex2");
  // No need to cast to JenaIRI
  final JenaRDFTerm defG = jena.asRDFTerm(Quad.defaultGraphNodeGenerated);
  final JenaLiteral lit = jena.createLiteral("Hello");
  final JenaGeneralizedQuadLike q = jena.createGeneralizedQuad(lit, ex1, ex2, defG);
  assertEquals(lit, q.getSubject()); // it's a literal!
  assertEquals(ex1, q.getPredicate());
  assertEquals(ex2, q.getObject());
  assertTrue(q.asJenaQuad().getSubject().isLiteral());
  assertFalse(q.getGraphName().isPresent());
  assertTrue(q.asJenaQuad().isDefaultGraph());
}

@Test
public void testBinaryResource() {
  final String mimeType = "image/jpeg";
  final IRI binaryIdentifier = rdf.createIRI("file:///binary");
  final JenaDataset dataset = buildLdpDataset(LDP.NonRDFSource);
  dataset.add(Trellis.PreferServerManaged, identifier, DC.hasPart, binaryIdentifier);
  dataset.add(Trellis.PreferServerManaged, binaryIdentifier, DC.format, rdf.createLiteral(mimeType));
  auditService.creation(identifier, mockSession).forEach(q ->
      dataset.add(auditId, q.getSubject(), q.getPredicate(), q.getObject()));
  final TriplestoreResource res = new TriplestoreResource(connect(wrap(dataset.asJenaDatasetGraph())),
      identifier);
  res.fetchData();
  assertTrue(res.exists(), "Missing resource!");
  res.getBinaryMetadata().ifPresent(b -> {
    assertEquals(binaryIdentifier, b.getIdentifier(), "Incorrect binary identifier!");
    assertEquals(of(mimeType), b.getMimeType(), "Incorrect binary mime type!");
  });
  assertAll("Check resource", checkResource(res, identifier, LDP.NonRDFSource, true, false, false));
  assertAll("Check LDP properties", checkLdpProperties(res, null, null, null, null));
  assertAll("Check RDF stream", checkRdfStream(res, 2L, 0L, 5L, 0L, 0L));
}