use of nl.knaw.huygens.timbuctoo.rdf.Database.RDF_SYNONYM_PROP in project timbuctoo by HuygensING.
the class DatabaseTest method findOrCreateEntityGivesABlankNodeADefaultUri.
@Test
public void findOrCreateEntityGivesABlankNodeADefaultUri() {
TinkerPopGraphManager graphWrapper = newGraph().withVertex(v -> v.withLabel(Vre.DATABASE_LABEL).withProperty("name", VRE_NAME)).withVertex(v -> {
v.withLabel(Vre.DATABASE_LABEL);
v.withProperty(Vre.VRE_NAME_PROPERTY_NAME, "Admin");
v.withOutgoingRelation(Vre.HAS_COLLECTION_RELATION_NAME, "defaultArchetype");
}).withVertex("defaultArchetype", v -> {
v.withProperty(ENTITY_TYPE_NAME_PROPERTY_NAME, "concept");
v.withProperty(COLLECTION_NAME_PROPERTY_NAME, "concepts");
v.withOutgoingRelation(HAS_ENTITY_NODE_RELATION_NAME, "entityCollection");
}).withVertex("entityCollection", v -> {
}).wrap();
final Database instance = new Database(graphWrapper, modifier);
Node blankNode = TripleCreator.createBlankNode();
String expectedUri = VRE_NAME + ":" + blankNode.getBlankNodeLabel();
Entity entity = instance.findOrCreateEntity(VRE_NAME, blankNode);
assertThat(entity, is(notNullValue()));
assertThat(entity.vertex.value(RDF_SYNONYM_PROP), is(new String[] { expectedUri }));
}
use of nl.knaw.huygens.timbuctoo.rdf.Database.RDF_SYNONYM_PROP in project timbuctoo by HuygensING.
the class TinkerPopToEntityMapper method mapEntity.
public ReadEntity mapEntity(GraphTraversal<Vertex, Vertex> entityT, boolean withRelations) {
final List<TimProperty<?>> properties = Lists.newArrayList();
TinkerPopPropertyConverter dbPropertyConverter = new TinkerPopPropertyConverter(collection);
String entityTypeName = collection.getEntityTypeName();
GraphTraversal[] propertyGetters = collection.getReadableProperties().entrySet().stream().map(prop -> prop.getValue().traversalRaw().sideEffect(x -> x.get().onSuccess(value -> {
try {
properties.add(dbPropertyConverter.from(prop.getKey(), value));
} catch (UnknownPropertyException e) {
LOG.error("Unknown property", e);
} catch (IOException e) {
LOG.error(databaseInvariant, "Property '" + prop.getKey() + "' is not encoded correctly", e.getCause());
}
}).onFailure(e -> {
if (e.getCause() instanceof IOException) {
LOG.error(databaseInvariant, "Property '" + prop.getKey() + "' is not encoded correctly", e.getCause());
} else {
LOG.error("Something went wrong while reading the property '" + prop.getKey() + "'.", e.getCause());
}
}))).toArray(GraphTraversal[]::new);
entityT.asAdmin().clone().union(propertyGetters).forEachRemaining(x -> {
// Force side effects to happen
});
ReadEntityImpl entity = new ReadEntityImpl();
entity.setProperties(properties);
Vertex entityVertex = entityT.asAdmin().clone().next();
// TODO make use conversion for the types
entity.setRev(getProp(entityVertex, "rev", Integer.class).orElse(-1));
entity.setDeleted(getProp(entityVertex, "deleted", Boolean.class).orElse(false));
entity.setPid(getProp(entityVertex, "pid", String.class).orElse(null));
URI rdfUri = getProp(entityVertex, RDF_URI_PROP, String.class).map(x -> {
try {
return new URI(x);
} catch (URISyntaxException e) {
return null;
}
}).orElse(null);
entity.setRdfUri(rdfUri);
Property<String[]> rdfAlternativesProp = entityVertex.property(RDF_SYNONYM_PROP);
if (rdfAlternativesProp.isPresent()) {
try {
entity.setRdfAlternatives(Lists.newArrayList(rdfAlternativesProp.value()));
} catch (Exception e) {
LOG.error(databaseInvariant, "Error while reading rdfAlternatives", e);
}
}
Optional<String> typesOptional = getProp(entityVertex, "types", String.class);
if (typesOptional.isPresent()) {
try {
List<String> types = new ObjectMapper().readValue(typesOptional.get(), new TypeReference<List<String>>() {
});
entity.setTypes(types);
} catch (Exception e) {
LOG.error(databaseInvariant, "Error while generating variation refs", e);
entity.setTypes(Lists.newArrayList(entityTypeName));
}
} else {
entity.setTypes(Lists.newArrayList(entityTypeName));
}
Optional<String> modifiedStringOptional = getProp(entityVertex, "modified", String.class);
if (modifiedStringOptional.isPresent()) {
try {
entity.setModified(new ObjectMapper().readValue(modifiedStringOptional.get(), Change.class));
} catch (IOException e) {
LOG.error(databaseInvariant, "Change cannot be converted", e);
entity.setModified(new Change());
}
} else {
entity.setModified(new Change());
}
Optional<String> createdStringOptional = getProp(entityVertex, "created", String.class);
if (createdStringOptional.isPresent()) {
try {
entity.setCreated(new ObjectMapper().readValue(createdStringOptional.get(), Change.class));
} catch (IOException e) {
LOG.error(databaseInvariant, "Change cannot be converted", e);
entity.setCreated(new Change());
}
} else {
entity.setCreated(new Change());
}
entity.setDisplayName(DisplayNameHelper.getDisplayname(traversalSource, entityVertex, collection).orElse(""));
entity.setId(getIdOrDefault(entityVertex));
if (withRelations) {
entity.setRelations(getRelations(entityVertex, traversalSource, collection));
}
customEntityProperties.execute(entity, entityVertex);
return entity;
}
use of nl.knaw.huygens.timbuctoo.rdf.Database.RDF_SYNONYM_PROP in project timbuctoo by HuygensING.
the class TinkerPopToEntityMapper method getRelations.
private List<RelationRef> getRelations(Vertex entity, GraphTraversalSource traversalSource, Collection collection) {
final Vre vre = collection.getVre();
Vre adminVre = mappings.getVre("Admin");
Map<String, Collection> collectionsOfVre = vre.getCollections();
Object[] relationTypes = traversalSource.V().has(T.label, LabelP.of("relationtype")).id().toList().toArray();
GraphTraversal<Vertex, RelationRef> realRelations = collectionsOfVre.values().stream().filter(Collection::isRelationCollection).findAny().map(Collection::getEntityTypeName).map(ownRelationType -> traversalSource.V(entity.id()).union(__.outE().as("edge").label().as("label").select("edge"), __.inE().as("edge").label().as("edgeLabel").V(relationTypes).has("relationtype_regularName", __.where(P.eq("edgeLabel"))).properties("relationtype_inverseName").value().as("label").select("edge")).where(// FIXME move to strategy
__.has("isLatest", true).not(__.has("deleted", true)).not(__.hasLabel("VERSION_OF")).not(__.has(ownRelationType + "_accepted", false))).otherV().as("vertex").select("edge", "vertex", "label").map(r -> {
try {
Map<String, Object> val = r.get();
Edge edge = (Edge) val.get("edge");
Vertex target = (Vertex) val.get("vertex");
String label = (String) val.get("label");
String targetEntityType = vre.getOwnType(getEntityTypesOrDefault(target));
Collection targetCollection = vre.getCollectionForTypeName(targetEntityType);
if (targetEntityType == null) {
// this means that the edge is of this VRE, but the
// Vertex it points to is of another VRE
// In that case we use the admin vre
targetEntityType = adminVre.getOwnType(getEntityTypesOrDefault(target));
targetCollection = adminVre.getCollectionForTypeName(targetEntityType);
}
String displayName = DisplayNameHelper.getDisplayname(traversalSource, target, targetCollection).orElse("<No displayname found>");
String targetId = getProp(target, "tim_id", String.class).orElse("");
String targetRdfUri = getProp(target, RDF_URI_PROP, String.class).orElse("");
String[] targetAlternativeUris = getProp(target, RDF_SYNONYM_PROP, String[].class).orElse(new String[0]);
boolean accepted = getProp(edge, "accepted", Boolean.class).orElse(true);
String relationId = getProp(edge, "tim_id", String.class).orElse("");
String relationRdfUri = getProp(edge, "rdfUri", String.class).orElse("");
int relationRev = getProp(edge, "rev", Integer.class).orElse(1);
RelationRef relationRef = new RelationRef(targetId, targetRdfUri, targetAlternativeUris, targetCollection.getCollectionName(), targetEntityType, accepted, relationId, relationRdfUri, relationRev, label, displayName);
customRelationProperties.execute(traversalSource, vre, target, relationRef);
return relationRef;
} catch (Exception e) {
LOG.error(databaseInvariant, "Something went wrong while formatting the entity", e);
return null;
}
})).orElse(EmptyGraph.instance().traversal().V().map(x -> null));
List<RelationRef> relations = stream(realRelations).filter(x -> x != null).collect(toList());
return relations;
}
Aggregations