private StreamingPropertyValue getStreamingPropertyValue(Vertex artifactVertex, String type) {
StreamingPropertyValue mediaPropertyValue;
if (MediaLumifyProperties.MIME_TYPE_AUDIO_MP4.equals(type)) {
mediaPropertyValue = MediaLumifyProperties.AUDIO_MP4.getPropertyValue(artifactVertex);
checkNotNull(
mediaPropertyValue,
String.format(
"Could not find %s property on artifact %s",
MediaLumifyProperties.AUDIO_MP4, artifactVertex.getId()));
} else if (MediaLumifyProperties.MIME_TYPE_AUDIO_OGG.equals(type)) {
mediaPropertyValue = MediaLumifyProperties.AUDIO_OGG.getPropertyValue(artifactVertex);
checkNotNull(
mediaPropertyValue,
String.format(
"Could not find %s property on artifact %s",
MediaLumifyProperties.AUDIO_OGG, artifactVertex.getId()));
} else if (MediaLumifyProperties.MIME_TYPE_VIDEO_MP4.equals(type)) {
mediaPropertyValue = MediaLumifyProperties.VIDEO_MP4.getPropertyValue(artifactVertex);
checkNotNull(
mediaPropertyValue,
String.format(
"Could not find %s property on artifact %s",
MediaLumifyProperties.VIDEO_MP4, artifactVertex.getId()));
} else if (MediaLumifyProperties.MIME_TYPE_VIDEO_WEBM.equals(type)) {
mediaPropertyValue = MediaLumifyProperties.VIDEO_WEBM.getPropertyValue(artifactVertex);
checkNotNull(
mediaPropertyValue,
String.format(
"Could not find %s property on artifact %s",
MediaLumifyProperties.VIDEO_WEBM, artifactVertex.getId()));
} else {
throw new RuntimeException("Invalid video type: " + type);
}
return mediaPropertyValue;
}
private void saveVertexRelationships(
List<VertexRelationship> vertexRelationships,
List<TermMentionWithGraphVertex> termMentionsWithGraphVertices) {
for (VertexRelationship vertexRelationship : vertexRelationships) {
TermMentionWithGraphVertex sourceTermMentionsWithGraphVertex =
findTermMentionWithGraphVertex(
termMentionsWithGraphVertices, vertexRelationship.getSource());
checkNotNull(sourceTermMentionsWithGraphVertex, "Could not find source");
checkNotNull(sourceTermMentionsWithGraphVertex.getVertex(), "Could not find source vertex");
Vertex targetVertex = graph.getVertex(vertexRelationship.getTargetId(), getAuthorizations());
checkNotNull(sourceTermMentionsWithGraphVertex, "Could not find target vertex");
String label = vertexRelationship.getLabel();
checkNotNull(label, "label is required");
Edge edge =
trySingle(
sourceTermMentionsWithGraphVertex
.getVertex()
.getEdges(targetVertex, Direction.OUT, label, getAuthorizations()));
if (edge == null) {
LOGGER.debug(
"adding edge %s -> %s (%s)",
sourceTermMentionsWithGraphVertex.getVertex().getId(), targetVertex.getId(), label);
graph.addEdge(
sourceTermMentionsWithGraphVertex.getVertex(),
targetVertex,
label,
vertexRelationship.getVisibility(),
getAuthorizations());
}
}
}
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, HandlerChain chain)
throws Exception {
final String graphVertexId = getAttributeString(request, "graphVertexId");
final String visibilitySource = getRequiredParameter(request, "visibilitySource");
User user = getUser(request);
Authorizations authorizations = getAuthorizations(request, user);
String workspaceId = getActiveWorkspaceId(request);
Vertex graphVertex = graph.getVertex(graphVertexId, authorizations);
if (graphVertex == null) {
respondWithNotFound(response);
return;
}
if (!graph.isVisibilityValid(new Visibility(visibilitySource), authorizations)) {
LOGGER.warn(
"%s is not a valid visibility for %s user", visibilitySource, user.getDisplayName());
respondWithBadRequest(response, "visibilitySource", getString(request, "visibility.invalid"));
chain.next(request, response);
return;
}
LOGGER.info(
"changing vertex (%s) visibility source to %s",
graphVertex.getId().toString(), visibilitySource);
GraphUtil.VisibilityAndElementMutation<Vertex> setPropertyResult =
GraphUtil.updateElementVisibilitySource(
visibilityTranslator,
graphVertex,
GraphUtil.getSandboxStatus(graphVertex, workspaceId),
visibilitySource,
workspaceId,
authorizations);
auditRepository.auditVertexElementMutation(
AuditAction.UPDATE,
setPropertyResult.elementMutation,
graphVertex,
"",
user,
setPropertyResult.visibility.getVisibility());
this.graph.flush();
this.workQueueRepository.pushGraphPropertyQueue(
graphVertex,
null,
LumifyVisibilityProperties.VISIBILITY_JSON_PROPERTY.getPropertyName(),
workspaceId,
visibilitySource);
JSONObject json = JsonSerializer.toJson(graphVertex, workspaceId, authorizations);
respondWithJson(response, json);
}
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, HandlerChain chain)
throws Exception {
boolean download = getOptionalParameter(request, "download") != null;
boolean playback = getOptionalParameter(request, "playback") != null;
User user = getUser(request);
Authorizations authorizations = getAuthorizations(request, user);
String graphVertexId = UrlUtils.urlDecode(getAttributeString(request, "graphVertexId"));
Vertex artifactVertex = graph.getVertex(graphVertexId, authorizations);
if (artifactVertex == null) {
respondWithNotFound(response);
return;
}
String fileName = LumifyProperties.FILE_NAME.getPropertyValue(artifactVertex);
if (fileName == null) {
fileName = LumifyProperties.TITLE.getPropertyValue(artifactVertex);
}
if (playback) {
handlePartialPlayback(request, response, artifactVertex, fileName, user);
} else {
String mimeType = getMimeType(artifactVertex);
response.setContentType(mimeType);
setMaxAge(response, EXPIRES_1_HOUR);
if (download) {
response.addHeader("Content-Disposition", "attachment; filename=" + fileName);
} else {
response.addHeader("Content-Disposition", "inline; filename=" + fileName);
}
StreamingPropertyValue rawValue = LumifyProperties.RAW.getPropertyValue(artifactVertex);
if (rawValue == null) {
LOGGER.warn("Could not find raw on artifact: %s", artifactVertex.getId().toString());
respondWithNotFound(response);
return;
}
InputStream in = rawValue.getInputStream();
try {
IOUtils.copy(in, response.getOutputStream());
} finally {
in.close();
}
}
chain.next(request, response);
}
protected List<TermMentionWithGraphVertex> saveTermMentions(
Vertex artifactGraphVertex,
Iterable<TermMention> termMentions,
String workspaceId,
String visibilitySource) {
getAuditRepository()
.auditAnalyzedBy(
AuditAction.ANALYZED_BY,
artifactGraphVertex,
getClass().getSimpleName(),
getUser(),
artifactGraphVertex.getVisibility());
for (TermMentionFilter termMentionFilter : this.workerPrepareData.getTermMentionFilters()) {
try {
termMentions = termMentionFilter.apply(artifactGraphVertex, termMentions);
} catch (Exception ex) {
throw new LumifyException(
"Failed to run term mention filter: " + termMentionFilter.getClass().getName(), ex);
}
}
List<TermMentionWithGraphVertex> results = new ArrayList<TermMentionWithGraphVertex>();
for (TermMention termMention : termMentions) {
results.add(saveTermMention(artifactGraphVertex, termMention, workspaceId, visibilitySource));
}
return results;
}
private void safeMap(LongWritable filePosition, Text line, Context context)
throws IOException, InterruptedException {
String lineString = line.toString();
int colonOffet = lineString.indexOf(':');
if (colonOffet < 1) {
return;
}
long userId = Long.parseLong(lineString.substring(0, colonOffet));
context.setStatus("User: "******"Friendster MR", "", user, visibility);
context.write(key, AccumuloSession.createMutationFromRow(audit));
String friends = lineString.substring(colonOffet + 1).trim();
if ("notfound".equals(friends) || "private".equals(friends)) {
// do nothing?
} else {
String[] friendsArray = friends.split(",");
for (String friend : friendsArray) {
friend = friend.trim();
if (friend.length() == 0) {
continue;
}
long friendId = Long.parseLong(friend);
Vertex friendVertex = createUserVertex(friendId);
addEdge(
ImportMR.getFriendEdgeId(userVertex, friendVertex),
userVertex,
friendVertex,
FriendsterOntology.EDGE_LABEL_FRIEND,
visibility,
authorizations);
context.getCounter(FriendsterImportCounters.FRIEND_EDGES_CREATED).increment(1);
}
}
context.getCounter(FriendsterImportCounters.USERS_PROCESSED).increment(1);
}
@Override
public void execute(InputStream in, GraphPropertyWorkData data) throws Exception {
LOGGER.debug("Extracting pattern [%s] from provided text", pattern);
final String text = CharStreams.toString(new InputStreamReader(in, Charsets.UTF_8));
final Matcher matcher = pattern.matcher(text);
List<TermMention> termMentions = new ArrayList<TermMention>();
while (matcher.find()) {
TermMention termMention =
createTerm(matcher, data.getProperty().getKey(), data.getVisibility());
termMentions.add(termMention);
}
Vertex v = (Vertex) data.getElement();
getAuditRepository()
.auditAnalyzedBy(
AuditAction.ANALYZED_BY, v, getClass().getSimpleName(), getUser(), v.getVisibility());
saveTermMentions((Vertex) data.getElement(), termMentions);
}
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, HandlerChain chain)
throws Exception {
final String artifactId = getRequiredParameter(request, "artifactId");
final String propertyKey = getRequiredParameter(request, "propertyKey");
final long mentionStart = getRequiredParameterAsLong(request, "mentionStart");
final long mentionEnd = getRequiredParameterAsLong(request, "mentionEnd");
final String title = getRequiredParameter(request, "sign");
final String conceptId = getRequiredParameter(request, "conceptId");
final String visibilitySource = getRequiredParameter(request, "visibilitySource");
final String resolvedVertexId = getOptionalParameter(request, "resolvedVertexId");
final String justificationText = getOptionalParameter(request, "justificationText");
final String sourceInfo = getOptionalParameter(request, "sourceInfo");
String termMentionRowKeyString = getOptionalParameter(request, "rowKey");
User user = getUser(request);
String workspaceId = getActiveWorkspaceId(request);
Workspace workspace = workspaceRepository.findById(workspaceId, user);
Authorizations authorizations = getAuthorizations(request, user);
JSONObject visibilityJson =
GraphUtil.updateVisibilitySourceAndAddWorkspaceId(null, visibilitySource, workspaceId);
LumifyVisibility visibility = this.visibilityTranslator.toVisibility(visibilityJson);
if (!graph.isVisibilityValid(visibility.getVisibility(), authorizations)) {
LOGGER.warn(
"%s is not a valid visibility for %s user", visibilitySource, user.getDisplayName());
respondWithBadRequest(response, "visibilitySource", STRINGS.getString("visibility.invalid"));
chain.next(request, response);
return;
}
Object id = resolvedVertexId == null ? graph.getIdGenerator().nextId() : resolvedVertexId;
Concept concept = ontologyRepository.getConceptByIRI(conceptId);
final Vertex artifactVertex = graph.getVertex(artifactId, authorizations);
LumifyVisibility lumifyVisibility = visibilityTranslator.toVisibility(visibilityJson);
Map<String, Object> metadata = new HashMap<String, Object>();
LumifyVisibilityProperties.VISIBILITY_JSON_PROPERTY.setMetadata(metadata, visibilityJson);
ElementMutation<Vertex> vertexMutation;
Vertex vertex;
if (resolvedVertexId != null) {
vertex = graph.getVertex(id, authorizations);
vertexMutation = vertex.prepareMutation();
} else {
vertexMutation = graph.prepareVertex(id, lumifyVisibility.getVisibility());
GraphUtil.addJustificationToMutation(
vertexMutation, justificationText, sourceInfo, lumifyVisibility);
CONCEPT_TYPE.setProperty(
vertexMutation, conceptId, metadata, lumifyVisibility.getVisibility());
TITLE.addPropertyValue(
vertexMutation, MULTI_VALUE_KEY, title, metadata, lumifyVisibility.getVisibility());
vertex = vertexMutation.save(authorizations);
auditRepository.auditVertexElementMutation(
AuditAction.UPDATE, vertexMutation, vertex, "", user, lumifyVisibility.getVisibility());
LumifyVisibilityProperties.VISIBILITY_JSON_PROPERTY.setProperty(
vertexMutation, visibilityJson, metadata, lumifyVisibility.getVisibility());
this.graph.flush();
workspaceRepository.updateEntityOnWorkspace(
workspace, vertex.getId(), false, null, null, user);
}
// TODO: a better way to check if the same edge exists instead of looking it up every time?
Edge edge =
graph.addEdge(
artifactVertex,
vertex,
this.artifactHasEntityIri,
lumifyVisibility.getVisibility(),
authorizations);
LumifyVisibilityProperties.VISIBILITY_JSON_PROPERTY.setProperty(
edge, visibilityJson, metadata, lumifyVisibility.getVisibility(), authorizations);
auditRepository.auditRelationship(
AuditAction.CREATE,
artifactVertex,
vertex,
edge,
"",
"",
user,
lumifyVisibility.getVisibility());
TermMentionRowKey termMentionRowKey;
if (termMentionRowKeyString != null) {
termMentionRowKey = new TermMentionRowKey(RowKeyHelper.jsonDecode(termMentionRowKeyString));
} else {
termMentionRowKey =
new TermMentionRowKey(
artifactId, propertyKey, mentionStart, mentionEnd, edge.getId().toString());
}
TermMentionModel termMention = new TermMentionModel(termMentionRowKey);
termMention
.getMetadata()
.setSign(title, lumifyVisibility.getVisibility())
.setOntologyClassUri(concept.getDisplayName(), lumifyVisibility.getVisibility())
.setConceptGraphVertexId(concept.getTitle(), lumifyVisibility.getVisibility())
.setVertexId(vertex.getId().toString(), lumifyVisibility.getVisibility())
.setEdgeId(edge.getId().toString(), lumifyVisibility.getVisibility());
termMentionRepository.save(termMention);
vertexMutation.addPropertyValue(
graph.getIdGenerator().nextId().toString(),
LumifyProperties.ROW_KEY.getPropertyName(),
termMentionRowKey.toString(),
metadata,
lumifyVisibility.getVisibility());
vertexMutation.save(authorizations);
this.graph.flush();
workQueueRepository.pushTextUpdated(artifactId);
workQueueRepository.pushElement(edge);
JSONObject result = new JSONObject();
result.put("success", true);
respondWithJson(response, result);
}
static String getWikipediaPageToPageEdgeId(Vertex pageVertex, Vertex linkedPageVertex) {
return WIKIPEDIA_LINK_ID_PREFIX
+ getWikipediaPageTitleFromId(pageVertex.getId())
+ "_"
+ getWikipediaPageTitleFromId(linkedPageVertex.getId());
}
@Test
public void testEntities() {
int startingVertexCount = graph.getAllVertices().size();
int startingEdgeCount = graph.getAllEdges().size();
String workspaceId = "testWorkspaceId";
idGenerator.push(workspaceId);
idGenerator.push(workspaceId + "_to_" + user1.getUserId());
Workspace workspace = workspaceRepository.add("workspace1", user1);
assertEquals(
startingVertexCount + 1, graph.getAllVertices().size()); // +1 = the workspace vertex
assertEquals(
startingEdgeCount + 1,
graph.getAllEdges().size()); // +1 = the edges between workspaces and users
try {
workspaceRepository.updateEntityOnWorkspace(
workspace, entity1Vertex.getId(), true, 100, 100, user2);
fail("user2 should not have write access to workspace");
} catch (LumifyAccessDeniedException ex) {
assertEquals(user2, ex.getUser());
assertEquals(workspace.getId(), ex.getResourceId());
}
idGenerator.push(workspaceId + "_to_" + entity1Vertex.getId());
workspaceRepository.updateEntityOnWorkspace(
workspace, entity1Vertex.getId(), true, 100, 200, user1);
assertEquals(
startingVertexCount + 1, graph.getAllVertices().size()); // +1 = the workspace vertex
assertEquals(
startingEdgeCount + 2,
graph.getAllEdges().size()); // +2 = the edges between workspaces, users, and entities
workspaceRepository.updateEntityOnWorkspace(
workspace, entity1Vertex.getId(), true, 200, 300, user1);
assertEquals(
startingVertexCount + 1, graph.getAllVertices().size()); // +1 = the workspace vertex
assertEquals(
startingEdgeCount + 2,
graph.getAllEdges().size()); // +2 = the edges between workspaces, users, and entities
List<WorkspaceEntity> entities = workspaceRepository.findEntities(workspace, user1);
assertEquals(1, entities.size());
assertEquals(entity1Vertex.getId(), entities.get(0).getEntityVertexId());
assertEquals(200, entities.get(0).getGraphPositionX().intValue());
assertEquals(300, entities.get(0).getGraphPositionY().intValue());
try {
workspaceRepository.findEntities(workspace, user2);
fail("user2 should not have read access to workspace");
} catch (LumifyAccessDeniedException ex) {
assertEquals(user2, ex.getUser());
assertEquals(workspace.getId(), ex.getResourceId());
}
try {
workspaceRepository.softDeleteEntityFromWorkspace(workspace, entity1Vertex.getId(), user2);
fail("user2 should not have write access to workspace");
} catch (LumifyAccessDeniedException ex) {
assertEquals(user2, ex.getUser());
assertEquals(workspace.getId(), ex.getResourceId());
}
workspaceRepository.softDeleteEntityFromWorkspace(workspace, entity1Vertex.getId(), user1);
assertEquals(
startingVertexCount + 1, graph.getAllVertices().size()); // +1 = the workspace vertex
Map<String, InMemoryEdge> edgesAfterDelete = graph.getAllEdges();
assertEquals(
startingEdgeCount + 2, edgesAfterDelete.size()); // +1 = the edges between workspaces, users
boolean foundRemovedEdge = false;
for (InMemoryEdge edge : edgesAfterDelete.values()) {
if (edge.getLabel().equals(workspaceToEntityRelationship.getIRI())) {
assertEquals(
false, WorkspaceLumifyProperties.WORKSPACE_TO_ENTITY_VISIBLE.getPropertyValue(edge));
foundRemovedEdge = true;
}
}
assertTrue(foundRemovedEdge);
}
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, HandlerChain chain)
throws Exception {
long totalStartTime = System.nanoTime();
final String query;
final String filter = getRequiredParameter(request, "filter");
final int offset = (int) getOptionalParameterLong(request, "offset", 0);
final int size = (int) getOptionalParameterLong(request, "size", DEFAULT_RESULT_COUNT);
final String conceptType = getOptionalParameter(request, "conceptType");
final String getLeafNodes = getOptionalParameter(request, "leafNodes");
final String relatedToVertexId = getOptionalParameter(request, "relatedToVertexId");
if (relatedToVertexId == null) {
query = getRequiredParameter(request, "q");
} else {
query = getOptionalParameter(request, "q");
}
long startTime = System.nanoTime();
User user = getUser(request);
Authorizations authorizations = getAuthorizations(request, user);
String workspaceId = getActiveWorkspaceId(request);
ModelUserContext modelUserContext =
userRepository.getModelUserContext(authorizations, workspaceId);
JSONArray filterJson = new JSONArray(filter);
ontologyRepository.resolvePropertyIds(filterJson);
graph.flush();
LOGGER.debug("search %s\n%s", query, filterJson.toString(2));
Query graphQuery;
if (relatedToVertexId == null) {
graphQuery = graph.query(query, authorizations);
} else if (query == null || StringUtils.isBlank(query)) {
graphQuery = graph.getVertex(relatedToVertexId, authorizations).query(authorizations);
} else {
graphQuery = graph.getVertex(relatedToVertexId, authorizations).query(query, authorizations);
}
for (int i = 0; i < filterJson.length(); i++) {
JSONObject obj = filterJson.getJSONObject(i);
if (obj.length() > 0) {
updateQueryWithFilter(graphQuery, obj);
}
}
if (conceptType != null) {
Concept concept = ontologyRepository.getConceptByIRI(conceptType);
if (getLeafNodes == null || !getLeafNodes.equals("false")) {
List<Concept> leafNodeList = ontologyRepository.getAllLeafNodesByConcept(concept);
if (leafNodeList.size() > 0) {
String[] conceptIds = new String[leafNodeList.size()];
int count = 0;
for (Concept c : leafNodeList) {
conceptIds[count] = c.getTitle();
count++;
}
graphQuery.has(CONCEPT_TYPE.getPropertyName(), Compare.IN, conceptIds);
}
} else {
graphQuery.has(CONCEPT_TYPE.getPropertyName(), conceptType);
}
}
graphQuery.limit(size);
graphQuery.skip(offset);
Iterable<Vertex> searchResults;
try {
searchResults = graphQuery.vertices();
} catch (SearchPhaseExecutionException ex) {
respondWithBadRequest(response, "q", "Invalid Query");
return;
}
Map<Object, Double> scores = null;
if (searchResults instanceof IterableWithScores) {
scores = ((IterableWithScores) searchResults).getScores();
}
long retrievalStartTime = System.nanoTime();
List<JSONObject> verticesJsonList = new ArrayList<JSONObject>();
for (Vertex vertex : searchResults) {
JSONObject vertexJson = JsonSerializer.toJson(vertex, workspaceId);
if (scores != null) {
vertexJson.put("score", scores.get(vertex.getId()));
}
vertexJson.put(
"detectedObjects",
detectedObjectRepository.toJSON(vertex, modelUserContext, authorizations, workspaceId));
verticesJsonList.add(vertexJson);
}
long retrievalEndTime = System.nanoTime();
Collections.sort(
verticesJsonList,
new Comparator<JSONObject>() {
@Override
public int compare(JSONObject o1, JSONObject o2) {
double score1 = o1.optDouble("score", 0.0);
double score2 = o2.optDouble("score", 0.0);
return -Double.compare(score1, score2);
}
});
JSONArray verticesJson = new JSONArray();
for (JSONObject vertexJson : verticesJsonList) {
verticesJson.put(vertexJson);
}
long totalEndTime = System.nanoTime();
JSONObject results = new JSONObject();
results.put("vertices", verticesJson);
results.put("nextOffset", offset + size);
results.put("retrievalTime", retrievalEndTime - retrievalStartTime);
results.put("totalTime", totalEndTime - totalStartTime);
if (searchResults instanceof IterableWithTotalHits) {
results.put("totalHits", ((IterableWithTotalHits) searchResults).getTotalHits());
}
if (searchResults instanceof IterableWithSearchTime) {
results.put(
"searchTime", ((IterableWithSearchTime) searchResults).getSearchTimeNanoSeconds());
}
long endTime = System.nanoTime();
LOGGER.info(
"Search for \"%s\" found %d vertices in %dms",
query, verticesJsonList.size(), (endTime - startTime) / 1000 / 1000);
respondWithJson(response, results);
}
private TermMentionWithGraphVertex saveTermMention(
Vertex artifactGraphVertex,
TermMention termMention,
String workspaceId,
String visibilitySource) {
LOGGER.debug(
"Saving term mention '%s':%s:%s (%d:%d)",
termMention.getSign(),
termMention.getOntologyClassUri(),
termMention.getPropertyKey(),
termMention.getStart(),
termMention.getEnd());
Vertex vertex = null;
if (visibilitySource == null) {
visibilitySource = termMention.getVisibility().getVisibilityString();
}
JSONObject visibilityJson = new JSONObject();
visibilityJson.put(VisibilityTranslator.JSON_SOURCE, visibilitySource);
Visibility visibility = visibilityTranslator.toVisibility(visibilityJson).getVisibility();
Visibility visibilityWithWorkspaceId;
JSONObject visibilityJsonWithWorkspaceId;
if (!workspaceId.equals("")) {
visibilityJsonWithWorkspaceId =
GraphUtil.updateVisibilitySourceAndAddWorkspaceId(null, visibilitySource, workspaceId);
visibilityWithWorkspaceId =
visibilityTranslator.toVisibility(visibilityJsonWithWorkspaceId).getVisibility();
} else {
visibilityWithWorkspaceId = visibility;
visibilityJsonWithWorkspaceId = visibilityJson;
}
TermMentionRowKey termMentionRowKey =
new TermMentionRowKey(
artifactGraphVertex.getId().toString(),
termMention.getPropertyKey(),
termMention.getStart(),
termMention.getEnd());
TermMentionModel termMentionModel = new TermMentionModel(termMentionRowKey);
termMentionModel.getMetadata().setSign(termMention.getSign(), visibility);
termMentionModel
.getMetadata()
.setOntologyClassUri(termMention.getOntologyClassUri(), visibility);
if (termMention.getProcess() != null && !termMention.getProcess().equals("")) {
termMentionModel.getMetadata().setAnalyticProcess(termMention.getProcess(), visibility);
}
Concept concept = ontologyRepository.getConceptByIRI(termMention.getOntologyClassUri());
if (concept == null) {
LOGGER.error("Could not find ontology graph vertex '%s'", termMention.getOntologyClassUri());
return null;
}
termMentionModel.getMetadata().setConceptGraphVertexId(concept.getTitle(), visibility);
if (termMention.isResolved()) {
String title = termMention.getSign();
ElementMutation<Vertex> vertexElementMutation;
if (termMention.getUseExisting()) {
graph.flush(); // make sure the previous term mentions have made it into the graph
if (termMention.getId() != null) {
vertex = graph.getVertex(termMention.getId(), getAuthorizations());
} else {
vertex =
singleOrDefault(
graph
.query(getAuthorizations())
.has(LumifyProperties.TITLE.getPropertyName(), title)
.has(LumifyProperties.CONCEPT_TYPE.getPropertyName(), concept.getTitle())
.vertices(),
null);
}
}
Map<String, Object> metadata = new HashMap<String, Object>();
LumifyVisibilityProperties.VISIBILITY_JSON_PROPERTY.setMetadata(
metadata, visibilityJsonWithWorkspaceId);
if (vertex == null) {
if (termMention.getId() != null) {
vertexElementMutation =
graph.prepareVertex(termMention.getId(), visibilityWithWorkspaceId);
} else {
vertexElementMutation = graph.prepareVertex(visibilityWithWorkspaceId);
}
LumifyProperties.TITLE.setProperty(
vertexElementMutation, title, metadata, visibilityWithWorkspaceId);
LumifyProperties.CONCEPT_TYPE.setProperty(
vertexElementMutation, concept.getTitle(), metadata, visibilityWithWorkspaceId);
} else {
vertexElementMutation = vertex.prepareMutation();
}
for (TermMention.TermMentionProperty termMentionProperty : termMention.getNewProperties()) {
vertexElementMutation.addPropertyValue(
termMentionProperty.getKey(),
termMentionProperty.getName(),
termMentionProperty.getValue(),
metadata,
visibilityWithWorkspaceId);
}
LumifyVisibilityProperties.VISIBILITY_JSON_PROPERTY.setProperty(
vertexElementMutation,
visibilityJsonWithWorkspaceId,
metadata,
visibilityWithWorkspaceId);
vertexElementMutation.addPropertyValue(
graph.getIdGenerator().nextId(),
LumifyProperties.ROW_KEY.getPropertyName(),
termMentionRowKey.toString(),
metadata,
visibilityWithWorkspaceId);
if (!(vertexElementMutation instanceof ExistingElementMutation)) {
vertex = vertexElementMutation.save(getAuthorizations());
auditRepository.auditVertexElementMutation(
AuditAction.UPDATE,
vertexElementMutation,
vertex,
termMention.getProcess(),
getUser(),
visibilityWithWorkspaceId);
} else {
auditRepository.auditVertexElementMutation(
AuditAction.UPDATE,
vertexElementMutation,
vertex,
termMention.getProcess(),
getUser(),
visibilityWithWorkspaceId);
vertex = vertexElementMutation.save(getAuthorizations());
}
// TODO: a better way to check if the same edge exists instead of looking it up every time?
Edge edge =
singleOrDefault(
artifactGraphVertex.getEdges(
vertex, Direction.OUT, artifactHasEntityIri, getAuthorizations()),
null);
if (edge == null) {
edge =
graph.addEdge(
artifactGraphVertex, vertex, artifactHasEntityIri, visibility, getAuthorizations());
LumifyVisibilityProperties.VISIBILITY_JSON_PROPERTY.setProperty(
edge,
visibilityJsonWithWorkspaceId,
metadata,
visibilityWithWorkspaceId,
getAuthorizations());
auditRepository.auditRelationship(
AuditAction.CREATE,
artifactGraphVertex,
vertex,
edge,
termMention.getProcess(),
"",
getUser(),
visibilityWithWorkspaceId);
}
graph.flush();
if (workspaceId != null && !workspaceId.equals("")) {
Workspace workspace = workspaceRepository.findById(workspaceId, getUser());
workspaceRepository.updateEntityOnWorkspace(
workspace, vertex.getId(), null, null, null, getUser());
}
termMentionModel
.getMetadata()
.setVertexId(vertex.getId().toString(), visibility)
.setEdgeId(edge.getId().toString(), visibility);
}
getTermMentionRepository().save(termMentionModel, FlushFlag.NO_FLUSH);
return new TermMentionWithGraphVertex(termMentionModel, vertex);
}
public SecureGraphWorkspace(Vertex workspaceVertex) {
this.displayTitle = WorkspaceLumifyProperties.TITLE.getPropertyValue(workspaceVertex);
this.workspaceId = workspaceVertex.getId().toString();
this.workspaceVertex = workspaceVertex;
}
