2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
20 package org.openecomp.sdc.be.dao.janusgraph;
22 import static org.apache.commons.collections.CollectionUtils.isEmpty;
24 import fj.data.Either;
25 import java.io.IOException;
26 import java.util.ArrayList;
27 import java.util.HashMap;
28 import java.util.Iterator;
29 import java.util.List;
31 import java.util.Map.Entry;
32 import java.util.function.Predicate;
33 import java.util.stream.Collectors;
34 import java.util.stream.StreamSupport;
35 import java.util.Optional;
36 import org.apache.commons.collections.MapUtils;
37 import org.apache.commons.lang.StringUtils;
38 import org.apache.commons.lang3.tuple.ImmutablePair;
39 import org.apache.tinkerpop.gremlin.structure.Direction;
40 import org.apache.tinkerpop.gremlin.structure.Edge;
41 import org.apache.tinkerpop.gremlin.structure.Element;
42 import org.apache.tinkerpop.gremlin.structure.Property;
43 import org.apache.tinkerpop.gremlin.structure.Vertex;
44 import org.apache.tinkerpop.gremlin.structure.util.ElementHelper;
45 import org.janusgraph.core.JanusGraph;
46 import org.janusgraph.core.JanusGraphEdge;
47 import org.janusgraph.core.JanusGraphQuery;
48 import org.janusgraph.core.JanusGraphVertex;
49 import org.janusgraph.core.JanusGraphVertexQuery;
50 import org.janusgraph.core.PropertyKey;
51 import org.janusgraph.graphdb.query.JanusGraphPredicate;
52 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
53 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
54 import org.openecomp.sdc.be.dao.jsongraph.types.EdgePropertyEnum;
55 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
56 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
57 import org.openecomp.sdc.be.dao.jsongraph.utils.JsonParserUtils;
58 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
59 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
60 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
61 import org.openecomp.sdc.be.datatypes.enums.ModelTypeEnum;
62 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
63 import org.openecomp.sdc.common.jsongraph.util.CommonUtility;
64 import org.openecomp.sdc.common.jsongraph.util.CommonUtility.LogLevelEnum;
65 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
66 import org.openecomp.sdc.common.log.wrappers.Logger;
67 import org.springframework.beans.factory.annotation.Qualifier;
69 public class JanusGraphDao {
71 private static final Logger logger = Logger.getLogger(JanusGraphDao.class);
72 JanusGraphClient janusGraphClient;
74 public JanusGraphDao(@Qualifier("janusgraph-client") JanusGraphClient janusGraphClient) {
75 this.janusGraphClient = janusGraphClient;
76 logger.info("** JanusGraphDao created");
79 public JanusGraphOperationStatus commit() {
80 logger.debug("#commit - The operation succeeded. Doing commit...");
81 return janusGraphClient.commit();
84 public JanusGraphOperationStatus rollback() {
85 logger.debug("#rollback - The operation failed. Doing rollback...");
86 return janusGraphClient.rollback();
89 public Either<JanusGraph, JanusGraphOperationStatus> getGraph() {
90 return janusGraphClient.getGraph();
97 public Either<GraphVertex, JanusGraphOperationStatus> createVertex(GraphVertex graphVertex) {
98 logger.trace("try to create vertex for ID [{}]", graphVertex.getUniqueId());
99 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
100 if (graph.isLeft()) {
102 JanusGraph tGraph = graph.left().value();
103 JanusGraphVertex vertex = tGraph.addVertex();
104 setVertexProperties(vertex, graphVertex);
105 graphVertex.setVertex(vertex);
106 return Either.left(graphVertex);
107 } catch (Exception e) {
109 .error(EcompLoggerErrorCode.DATA_ERROR, "JanusGraphDao", "Failed to create Node for ID '{}'", (Object) graphVertex.getUniqueId(),
111 return Either.right(JanusGraphClient.handleJanusGraphException(e));
114 logger.debug("Failed to create vertex for ID '{}' {}", graphVertex.getUniqueId(), graph.right().value());
115 return Either.right(graph.right().value());
125 public Either<GraphVertex, JanusGraphOperationStatus> getVertexByPropertyAndLabel(GraphPropertyEnum name, Object value, VertexTypeEnum label) {
126 return getVertexByPropertyAndLabel(name, value, label, JsonParseFlagEnum.ParseAll);
129 public Either<GraphVertex, JanusGraphOperationStatus> getVertexByLabel(VertexTypeEnum label) {
130 return janusGraphClient.getGraph().left().map(graph -> graph.query().has(GraphPropertyEnum.LABEL.getProperty(), label.getName()).vertices())
131 .left().bind(janusGraphVertices -> getFirstFoundVertex(JsonParseFlagEnum.NoParse, janusGraphVertices));
134 private Either<GraphVertex, JanusGraphOperationStatus> getFirstFoundVertex(JsonParseFlagEnum parseFlag, Iterable<JanusGraphVertex> vertices) {
135 Iterator<JanusGraphVertex> iterator = vertices.iterator();
136 if (iterator.hasNext()) {
137 JanusGraphVertex vertex = iterator.next();
138 GraphVertex graphVertex = createAndFill(vertex, parseFlag);
139 return Either.left(graphVertex);
141 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
151 public Either<GraphVertex, JanusGraphOperationStatus> getVertexByPropertyAndLabel(GraphPropertyEnum name, Object value, VertexTypeEnum label,
152 JsonParseFlagEnum parseFlag) {
153 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
154 if (graph.isLeft()) {
156 JanusGraph tGraph = graph.left().value();
157 @SuppressWarnings("unchecked") Iterable<JanusGraphVertex> vertecies = tGraph.query().has(name.getProperty(), value)
158 .has(GraphPropertyEnum.LABEL.getProperty(), label.getName()).vertices();
159 java.util.Iterator<JanusGraphVertex> iterator = vertecies.iterator();
160 if (iterator.hasNext()) {
161 JanusGraphVertex vertex = iterator.next();
162 GraphVertex graphVertex = createAndFill(vertex, parseFlag);
163 return Either.left(graphVertex);
165 if (logger.isDebugEnabled()) {
166 logger.debug("No vertex in graph for key = {} and value = {} label = {}", name, value, label);
168 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
169 } catch (Exception e) {
170 if (logger.isDebugEnabled()) {
171 logger.debug("Failed to get vertex in graph for key ={} and value = {} label = {}", name, value, label);
173 return Either.right(JanusGraphClient.handleJanusGraphException(e));
176 if (logger.isDebugEnabled()) {
177 logger.debug("No vertex in graph for key ={} and value = {} label = {} error :{}", name, value, label, graph.right().value());
179 return Either.right(graph.right().value());
187 public Either<GraphVertex, JanusGraphOperationStatus> getVertexById(String id) {
188 return getVertexById(id, JsonParseFlagEnum.ParseAll);
196 public Either<GraphVertex, JanusGraphOperationStatus> getVertexById(String id, JsonParseFlagEnum parseFlag) {
197 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
199 if (logger.isDebugEnabled()) {
200 logger.debug("No vertex in graph for id = {} ", id);
202 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
204 if (graph.isLeft()) {
206 JanusGraph tGraph = graph.left().value();
207 @SuppressWarnings("unchecked") Iterable<JanusGraphVertex> vertecies = tGraph.query()
208 .has(GraphPropertyEnum.UNIQUE_ID.getProperty(), id).vertices();
209 java.util.Iterator<JanusGraphVertex> iterator = vertecies.iterator();
210 if (iterator.hasNext()) {
211 JanusGraphVertex vertex = iterator.next();
212 GraphVertex graphVertex = createAndFill(vertex, parseFlag);
213 return Either.left(graphVertex);
215 if (logger.isDebugEnabled()) {
216 logger.debug("No vertex in graph for id = {}", id);
218 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
220 } catch (Exception e) {
221 if (logger.isDebugEnabled()) {
222 logger.debug("Failed to get vertex in graph for id {} ", id);
224 return Either.right(JanusGraphClient.handleJanusGraphException(e));
227 if (logger.isDebugEnabled()) {
228 logger.debug("No vertex in graph for id {} error : {}", id, graph.right().value());
230 return Either.right(graph.right().value());
234 private void setVertexProperties(JanusGraphVertex vertex, GraphVertex graphVertex) throws IOException {
235 if (graphVertex.getMetadataProperties() != null) {
236 for (Map.Entry<GraphPropertyEnum, Object> entry : graphVertex.getMetadataProperties().entrySet()) {
237 if (entry.getValue() != null) {
238 vertex.property(entry.getKey().getProperty(), entry.getValue());
242 vertex.property(GraphPropertyEnum.LABEL.getProperty(), graphVertex.getLabel().getName());
243 Map<String, ? extends ToscaDataDefinition> json = graphVertex.getJson();
245 String jsonStr = JsonParserUtils.toJson(json);
246 vertex.property(GraphPropertyEnum.JSON.getProperty(), jsonStr);
248 Map<String, Object> jsonMetadata = graphVertex.getMetadataJson();
249 if (jsonMetadata != null) {
250 String jsonMetadataStr = JsonParserUtils.toJson(jsonMetadata);
251 vertex.property(GraphPropertyEnum.METADATA.getProperty(), jsonMetadataStr);
255 public void setVertexProperties(Vertex vertex, Map<String, Object> properties) throws IOException {
256 for (Map.Entry<String, Object> entry : properties.entrySet()) {
257 if (entry.getValue() != null) {
258 vertex.property(entry.getKey(), entry.getValue());
263 private GraphVertex createAndFill(JanusGraphVertex vertex, JsonParseFlagEnum parseFlag) {
264 GraphVertex graphVertex = new GraphVertex();
265 graphVertex.setVertex(vertex);
266 parseVertexProperties(graphVertex, parseFlag);
270 public void parseVertexProperties(GraphVertex graphVertex, JsonParseFlagEnum parseFlag) {
271 JanusGraphVertex vertex = graphVertex.getVertex();
272 Map<GraphPropertyEnum, Object> properties = getVertexProperties(vertex);
273 VertexTypeEnum label = VertexTypeEnum.getByName((String) (properties.get(GraphPropertyEnum.LABEL)));
274 for (Map.Entry<GraphPropertyEnum, Object> entry : properties.entrySet()) {
275 GraphPropertyEnum key = entry.getKey();
278 graphVertex.setUniqueId((String) entry.getValue());
281 graphVertex.setLabel(VertexTypeEnum.getByName((String) entry.getValue()));
284 String type = (String) entry.getValue();
286 graphVertex.setType(ComponentTypeEnum.valueOf(type));
290 if (parseFlag == JsonParseFlagEnum.ParseAll || parseFlag == JsonParseFlagEnum.ParseJson) {
291 String json = (String) entry.getValue();
292 Map<String, ? extends ToscaDataDefinition> jsonObj = JsonParserUtils.toMap(json, label.getClassOfJson());
293 graphVertex.setJson(jsonObj);
297 if (parseFlag == JsonParseFlagEnum.ParseAll || parseFlag == JsonParseFlagEnum.ParseMetadata) {
298 String json = (String) entry.getValue();
299 Map<String, Object> metadatObj = JsonParserUtils.toMap(json);
300 graphVertex.setMetadataJson(metadatObj);
304 graphVertex.addMetadataProperty(key, entry.getValue());
310 public JanusGraphOperationStatus createEdge(GraphVertex from, GraphVertex to, EdgeLabelEnum label, Map<EdgePropertyEnum, Object> properties) {
311 return createEdge(from.getVertex(), to.getVertex(), label, properties);
314 public JanusGraphOperationStatus createEdge(Vertex from, Vertex to, EdgeLabelEnum label, Map<EdgePropertyEnum, Object> properties) {
315 if (logger.isTraceEnabled()) {
316 logger.trace("Try to connect {} with {} label {} properties {}",
317 from == null ? "NULL" : from.property(GraphPropertyEnum.UNIQUE_ID.getProperty()),
318 to == null ? "NULL" : to.property(GraphPropertyEnum.UNIQUE_ID.getProperty()), label, properties);
320 if (from == null || to == null) {
321 logger.trace("No JanusGraph vertex for id from {} or id to {}",
322 from == null ? "NULL" : from.property(GraphPropertyEnum.UNIQUE_ID.getProperty()),
323 to == null ? "NULL" : to.property(GraphPropertyEnum.UNIQUE_ID.getProperty()));
324 return JanusGraphOperationStatus.NOT_FOUND;
326 Edge edge = from.addEdge(label.name(), to);
327 JanusGraphOperationStatus status;
329 setEdgeProperties(edge, properties);
330 status = JanusGraphOperationStatus.OK;
331 } catch (IOException e) {
332 logger.error(EcompLoggerErrorCode.DATA_ERROR, "JanusGraphDao", "Failed to set properties on edge properties [{}]", properties, e);
333 status = JanusGraphOperationStatus.GENERAL_ERROR;
338 public Map<GraphPropertyEnum, Object> getVertexProperties(Element element) {
339 Map<GraphPropertyEnum, Object> result = new HashMap<>();
340 if (element != null && element.keys() != null && element.keys().size() > 0) {
341 Map<String, Property> propertyMap = ElementHelper.propertyMap(element, element.keys().toArray(new String[element.keys().size()]));
342 for (Entry<String, Property> entry : propertyMap.entrySet()) {
343 String key = entry.getKey();
344 Object value = entry.getValue().value();
345 GraphPropertyEnum valueOf = GraphPropertyEnum.getByProperty(key);
346 if (valueOf != null) {
347 result.put(valueOf, value);
350 // add print to properties that can't be converted by enum
355 public Map<EdgePropertyEnum, Object> getEdgeProperties(Element element) {
356 Map<EdgePropertyEnum, Object> result = new HashMap<>();
357 if (element != null && element.keys() != null && element.keys().size() > 0) {
358 Map<String, Property> propertyMap = ElementHelper.propertyMap(element, element.keys().toArray(new String[element.keys().size()]));
359 for (Entry<String, Property> entry : propertyMap.entrySet()) {
360 String key = entry.getKey();
361 Object value = entry.getValue().value();
362 EdgePropertyEnum valueOf = EdgePropertyEnum.getByProperty(key);
363 if (valueOf != null) {
364 if (valueOf == EdgePropertyEnum.INSTANCES) {
365 List<String> list = JsonParserUtils.toList((String) value, String.class);
366 result.put(valueOf, list);
368 result.put(valueOf, value);
376 public void setEdgeProperties(Element element, Map<EdgePropertyEnum, Object> properties) throws IOException {
377 if (properties != null && !properties.isEmpty()) {
378 Object[] propertyKeyValues = new Object[properties.size() * 2];
380 for (Entry<EdgePropertyEnum, Object> entry : properties.entrySet()) {
381 propertyKeyValues[i++] = entry.getKey().getProperty();
382 Object value = entry.getValue();
383 if (entry.getKey() == EdgePropertyEnum.INSTANCES) {
384 String jsonStr = JsonParserUtils.toJson(value);
385 propertyKeyValues[i++] = jsonStr;
387 propertyKeyValues[i++] = entry.getValue();
390 ElementHelper.attachProperties(element, propertyKeyValues);
394 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(VertexTypeEnum type, Map<GraphPropertyEnum, Object> props) {
395 return getByCriteria(type, props, JsonParseFlagEnum.ParseAll);
398 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(VertexTypeEnum type, Map<GraphPropertyEnum, Object> props,
399 JsonParseFlagEnum parseFlag) {
400 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
401 if (graph.isLeft()) {
403 JanusGraph tGraph = graph.left().value();
404 JanusGraphQuery<? extends JanusGraphQuery> query = tGraph.query();
406 query = query.has(GraphPropertyEnum.LABEL.getProperty(), type.getName());
408 if (props != null && !props.isEmpty()) {
409 for (Map.Entry<GraphPropertyEnum, Object> entry : props.entrySet()) {
410 query = query.has(entry.getKey().getProperty(), entry.getValue());
413 Iterable<JanusGraphVertex> vertices = query.vertices();
414 if (vertices == null) {
415 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
417 Iterator<JanusGraphVertex> iterator = vertices.iterator();
418 List<GraphVertex> result = new ArrayList<>();
419 while (iterator.hasNext()) {
420 JanusGraphVertex vertex = iterator.next();
421 Map<GraphPropertyEnum, Object> newProp = getVertexProperties(vertex);
422 GraphVertex graphVertex = createAndFill(vertex, parseFlag);
423 result.add(graphVertex);
425 if (logger.isDebugEnabled()) {
427 .debug("Number of fetced nodes in graph for criteria : from type = {} and properties = {} is {}", type, props, result.size());
429 if (result.size() == 0) {
430 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
432 return Either.left(result);
433 } catch (Exception e) {
434 if (logger.isDebugEnabled()) {
435 logger.debug("Failed get by criteria for type = {} and properties = {}", type, props, e);
437 return Either.right(JanusGraphClient.handleJanusGraphException(e));
440 if (logger.isDebugEnabled()) {
441 logger.debug("Failed get by criteria for type ={} and properties = {} error : {}", type, props, graph.right().value());
443 return Either.right(graph.right().value());
447 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type, final Map<GraphPropertyEnum, Object> props,
448 final Map<GraphPropertyEnum, Object> hasNotProps,
449 final JsonParseFlagEnum parseFlag,
450 final String model) {
451 return getByCriteria(type, props, hasNotProps, null, parseFlag, model, false);
454 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type, final Map<GraphPropertyEnum, Object> props,
455 final Map<GraphPropertyEnum, Object> hasNotProps,
456 final JsonParseFlagEnum parseFlag,
458 final boolean includeNormativeExtensionModels) {
459 return getByCriteria(type, props, hasNotProps, null, parseFlag, model, includeNormativeExtensionModels);
462 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type,
463 final Map<GraphPropertyEnum, Object> hasProps,
464 final Map<GraphPropertyEnum, Object> hasNotProps,
465 final Map<String, Entry<JanusGraphPredicate, Object>> predicates,
466 final JsonParseFlagEnum parseFlag,
467 final String model) {
468 return getByCriteria(type, hasProps, hasNotProps, predicates, parseFlag, model, false);
471 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type,
472 final Map<GraphPropertyEnum, Object> hasProps,
473 final Map<GraphPropertyEnum, Object> hasNotProps,
474 final Map<String, Entry<JanusGraphPredicate, Object>> predicates,
475 final JsonParseFlagEnum parseFlag,
477 final boolean includeNormativeExtensionModels) {
478 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
479 if (graph.isLeft()) {
481 JanusGraph tGraph = graph.left().value();
482 JanusGraphQuery<? extends JanusGraphQuery> query = tGraph.query();
485 query = query.has(GraphPropertyEnum.LABEL.getProperty(), type.getName());
487 if (hasProps != null && !hasProps.isEmpty()) {
488 for (Map.Entry<GraphPropertyEnum, Object> entry : hasProps.entrySet()) {
489 query = query.has(entry.getKey().getProperty(), entry.getValue());
492 if (hasNotProps != null && !hasNotProps.isEmpty()) {
493 for (Map.Entry<GraphPropertyEnum, Object> entry : hasNotProps.entrySet()) {
494 if (entry.getValue() instanceof List) {
495 buildMultipleNegateQueryFromList(entry, query);
497 query = query.hasNot(entry.getKey().getProperty(), entry.getValue());
501 if (predicates != null && !predicates.isEmpty()) {
502 for (Map.Entry<String, Entry<JanusGraphPredicate, Object>> entry : predicates.entrySet()) {
503 JanusGraphPredicate predicate = entry.getValue().getKey();
504 Object object = entry.getValue().getValue();
505 query = query.has(entry.getKey(), predicate, object);
508 Iterable<JanusGraphVertex> vertices = query.vertices();
509 if (vertices == null || !vertices.iterator().hasNext()) {
510 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
512 List<GraphVertex> result = new ArrayList<>();
514 final Predicate<? super JanusGraphVertex> filterPredicate = StringUtils.isEmpty(model) ? this::vertexNotConnectedToAnyModel : vertex -> vertexValidForModel(vertex, model, includeNormativeExtensionModels);
515 final List<JanusGraphVertex> verticesForModel = StreamSupport.stream(vertices.spliterator(), false).filter(filterPredicate).collect(Collectors.toList());
516 if (verticesForModel == null || verticesForModel.size() == 0) {
517 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
520 verticesForModel.forEach(vertex -> result.add(createAndFill(vertex, parseFlag)));
521 if (logger.isDebugEnabled()) {
522 logger.debug("Number of fetched nodes in graph for criteria : from type '{}' and properties '{}' is '{}'", type, hasProps,
525 return Either.left(result);
526 } catch (Exception e) {
527 if (logger.isDebugEnabled()) {
528 logger.debug("Failed to get by criteria for type '{}' and properties '{}'", type, hasProps, e);
530 return Either.right(JanusGraphClient.handleJanusGraphException(e));
533 if (logger.isDebugEnabled()) {
534 logger.debug("Failed to get by criteria for type '{}' and properties '{}'. Error : '{}'", type, hasProps, graph.right().value());
536 return Either.right(graph.right().value());
540 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(VertexTypeEnum type,
541 Map<GraphPropertyEnum, Object> props, Map<GraphPropertyEnum, Object> hasNotProps,
542 JsonParseFlagEnum parseFlag) {
543 return getByCriteria(type, props, hasNotProps, null, parseFlag);
546 public Either<List<GraphVertex>, JanusGraphOperationStatus> getByCriteria(final VertexTypeEnum type,
547 final Map<GraphPropertyEnum, Object> hasProps, final Map<GraphPropertyEnum, Object> hasNotProps,
548 final Map<String, Entry<JanusGraphPredicate, Object>> predicates, final JsonParseFlagEnum parseFlag) {
549 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
550 if (graph.isLeft()) {
552 JanusGraph tGraph = graph.left().value();
553 JanusGraphQuery<? extends JanusGraphQuery> query = tGraph.query();
556 query = query.has(GraphPropertyEnum.LABEL.getProperty(), type.getName());
558 if (hasProps != null && !hasProps.isEmpty()) {
559 for (Map.Entry<GraphPropertyEnum, Object> entry : hasProps.entrySet()) {
560 query = query.has(entry.getKey().getProperty(), entry.getValue());
563 if (hasNotProps != null && !hasNotProps.isEmpty()) {
564 for (Map.Entry<GraphPropertyEnum, Object> entry : hasNotProps.entrySet()) {
565 if (entry.getValue() instanceof List) {
566 buildMultipleNegateQueryFromList(entry, query);
568 query = query.hasNot(entry.getKey().getProperty(), entry.getValue());
572 if (predicates != null && !predicates.isEmpty()) {
573 for (Map.Entry<String, Entry<JanusGraphPredicate, Object>> entry : predicates.entrySet()) {
574 JanusGraphPredicate predicate = entry.getValue().getKey();
575 Object object = entry.getValue().getValue();
576 query = query.has(entry.getKey(), predicate, object);
579 Iterable<JanusGraphVertex> vertices = query.vertices();
580 if (vertices == null || !vertices.iterator().hasNext()) {
581 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
583 List<GraphVertex> result = new ArrayList<>();
585 vertices.forEach(vertex -> result.add(createAndFill(vertex, parseFlag)));
586 if (logger.isDebugEnabled()) {
588 "Number of fetched nodes in graph for criteria : from type '{}' and properties '{}' is '{}'",
589 type, hasProps, result.size());
591 return Either.left(result);
592 } catch (Exception e) {
593 if (logger.isDebugEnabled()) {
594 logger.debug("Failed to get by criteria for type '{}' and properties '{}'", type, hasProps, e);
596 return Either.right(JanusGraphClient.handleJanusGraphException(e));
599 if (logger.isDebugEnabled()) {
600 logger.debug("Failed to get by criteria for type '{}' and properties '{}'. Error : '{}'", type,
601 hasProps, graph.right().value());
603 return Either.right(graph.right().value());
607 private boolean vertexValidForModel(final JanusGraphVertex vertex, final String model, final boolean includeNormativeExtensions) {
608 final String vertexLabel = (String)vertex.property(GraphPropertyEnum.LABEL.getProperty()).value();
609 final VertexTypeEnum vertexType = VertexTypeEnum.getByName(vertexLabel);
610 final GraphEdgeLabels edgeLabel = vertexType.equals(VertexTypeEnum.TOPOLOGY_TEMPLATE) ? GraphEdgeLabels.MODEL : GraphEdgeLabels.MODEL_ELEMENT;
611 final Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> modelVertices = getParentVerticies(vertex, edgeLabel);
613 return modelVertices.isLeft() && modelVertices.left().value().stream().anyMatch(vertexPair -> modelVertexMatchesModel(vertexPair.getLeft(), model, includeNormativeExtensions));
616 private boolean modelVertexMatchesModel(final JanusGraphVertex modelVertex, final String model, final boolean includeNormativeExtensions) {
617 if (model.equals((String)modelVertex.property("name").value())) {
620 final Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> derivedModels =
621 getParentVerticies(modelVertex, GraphEdgeLabels.DERIVED_FROM);
622 if (derivedModels.isLeft() && derivedModels.left().value().stream().anyMatch(derivedModel ->modelVertexMatchesModel(derivedModel.left, model, includeNormativeExtensions))) {
626 if (includeNormativeExtensions && isANormativeExtension(modelVertex)) {
627 final Either<List<Vertex>,JanusGraphOperationStatus> derivedFromModels =
628 getChildrenVertices(modelVertex, EdgeLabelEnum.DERIVED_FROM, JsonParseFlagEnum.ParseAll);
629 return derivedFromModels.isLeft() && derivedFromModels.left().value().stream().anyMatch(derivedFromModel -> model.equals((String)derivedFromModel.property("name").value()));
634 private boolean isANormativeExtension(final JanusGraphVertex modelVertex) {
635 return ModelTypeEnum.NORMATIVE_EXTENSION.getValue().equals((String)modelVertex.property(GraphPropertyEnum.MODEL_TYPE.getProperty()).value());
638 private Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> getParentVerticies(
639 final JanusGraphVertex rootVertex, final GraphEdgeLabels edgeType) {
640 return getEdgeVerticies(rootVertex, Direction.IN, edgeType);
643 private Either<List<ImmutablePair<JanusGraphVertex, Edge>>, JanusGraphOperationStatus> getEdgeVerticies(
644 final JanusGraphVertex rootVertex, final Direction direction, final GraphEdgeLabels edgeType) {
645 final List<ImmutablePair<JanusGraphVertex, Edge>> immutablePairs = new ArrayList<>();
646 final Iterator<Edge> edgesCreatorIterator = rootVertex.edges(direction, edgeType.getProperty());
647 if (edgesCreatorIterator != null) {
648 while (edgesCreatorIterator.hasNext()) {
649 Edge edge = edgesCreatorIterator.next();
650 JanusGraphVertex vertex = Direction.OUT.equals(direction)? (JanusGraphVertex) edge.inVertex() : (JanusGraphVertex) edge.outVertex();
651 ImmutablePair<JanusGraphVertex, Edge> immutablePair = new ImmutablePair<>(vertex, edge);
652 immutablePairs.add(immutablePair);
655 if (immutablePairs.isEmpty()) {
656 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
658 return Either.left(immutablePairs);
661 private boolean vertexNotConnectedToAnyModel(final JanusGraphVertex vertex) {
662 String vt = (String)vertex.property(GraphPropertyEnum.LABEL.getProperty()).value();
663 VertexTypeEnum vertexType = VertexTypeEnum.getByName(vt);
664 EdgeLabelEnum edgeLabel = vertexType.equals(VertexTypeEnum.TOPOLOGY_TEMPLATE) ? EdgeLabelEnum.MODEL : EdgeLabelEnum.MODEL_ELEMENT;
665 return !vertex.edges(Direction.IN, edgeLabel.name()).hasNext();
668 public Either<Iterator<Vertex>, JanusGraphOperationStatus> getCatalogOrArchiveVerticies(boolean isCatalog) {
669 Either<JanusGraph, JanusGraphOperationStatus> graph = janusGraphClient.getGraph();
670 if (graph.isLeft()) {
672 JanusGraph tGraph = graph.left().value();
673 String name = isCatalog ? VertexTypeEnum.CATALOG_ROOT.getName() : VertexTypeEnum.ARCHIVE_ROOT.getName();
674 Iterable<JanusGraphVertex> vCatalogIter = tGraph.query().has(GraphPropertyEnum.LABEL.getProperty(), name).vertices();
675 if (vCatalogIter == null) {
676 logger.debug("Failed to fetch catalog vertex");
677 return Either.right(JanusGraphOperationStatus.GENERAL_ERROR);
679 JanusGraphVertex catalogV = vCatalogIter.iterator().next();
680 if (catalogV == null) {
681 logger.debug("Failed to fetch catalog vertex");
682 return Either.right(JanusGraphOperationStatus.GENERAL_ERROR);
684 String edgeLabel = isCatalog ? EdgeLabelEnum.CATALOG_ELEMENT.name() : EdgeLabelEnum.ARCHIVE_ELEMENT.name();
685 Iterator<Vertex> vertices = catalogV.vertices(Direction.OUT, edgeLabel);
686 return Either.left(vertices);
687 } catch (Exception e) {
688 if (logger.isDebugEnabled()) {
689 logger.debug("Failed get by criteria: ", e);
691 return Either.right(JanusGraphClient.handleJanusGraphException(e));
694 if (logger.isDebugEnabled()) {
695 logger.debug("Failed get by criteria : ", graph.right().value());
697 return Either.right(graph.right().value());
701 private void buildMultipleNegateQueryFromList(Map.Entry<GraphPropertyEnum, Object> entry, JanusGraphQuery query) {
702 List<Object> negateList = (List<Object>) entry.getValue();
703 for (Object listItem : negateList) {
704 query.hasNot(entry.getKey().getProperty(), listItem);
709 * @param parentVertex
714 public Either<GraphVertex, JanusGraphOperationStatus> getChildVertex(GraphVertex parentVertex, EdgeLabelEnum edgeLabel,
715 JsonParseFlagEnum parseFlag) {
716 Either<List<GraphVertex>, JanusGraphOperationStatus> childrenVertecies = getChildrenVertices(parentVertex, edgeLabel, parseFlag);
717 if (childrenVertecies.isRight()) {
718 return Either.right(childrenVertecies.right().value());
720 return Either.left(childrenVertecies.left().value().get(0));
724 * @param parentVertex
729 public Either<Vertex, JanusGraphOperationStatus> getChildVertex(Vertex parentVertex, EdgeLabelEnum edgeLabel, JsonParseFlagEnum parseFlag) {
730 Either<List<Vertex>, JanusGraphOperationStatus> childrenVertecies = getChildrenVertices(parentVertex, edgeLabel, parseFlag);
731 if (childrenVertecies.isRight()) {
732 return Either.right(childrenVertecies.right().value());
734 return Either.left(childrenVertecies.left().value().get(0));
737 public Either<GraphVertex, JanusGraphOperationStatus> getParentVertex(GraphVertex parentVertex, EdgeLabelEnum edgeLabel,
738 JsonParseFlagEnum parseFlag) {
739 Either<List<GraphVertex>, JanusGraphOperationStatus> childrenVertecies = getParentVertices(parentVertex, edgeLabel, parseFlag);
740 if (childrenVertecies.isRight()) {
741 return Either.right(childrenVertecies.right().value());
743 if (isEmpty(childrenVertecies.left().value())) {
744 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
746 return Either.left(childrenVertecies.left().value().get(0));
749 public Either<Vertex, JanusGraphOperationStatus> getParentVertex(Vertex parentVertex, EdgeLabelEnum edgeLabel, JsonParseFlagEnum parseFlag) {
750 Either<List<Vertex>, JanusGraphOperationStatus> childrenVertecies = getParentVertices(parentVertex, edgeLabel, parseFlag);
751 if (childrenVertecies.isRight()) {
752 return Either.right(childrenVertecies.right().value());
754 if (isEmpty(childrenVertecies.left().value())) {
755 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
757 return Either.left(childrenVertecies.left().value().get(0));
761 * @param parentVertex
766 public Either<List<GraphVertex>, JanusGraphOperationStatus> getChildrenVertices(GraphVertex parentVertex, EdgeLabelEnum edgeLabel,
767 JsonParseFlagEnum parseFlag) {
768 return getAdjacentVertices(parentVertex, edgeLabel, parseFlag, Direction.OUT);
771 public Either<List<GraphVertex>, JanusGraphOperationStatus> getParentVertices(GraphVertex parentVertex, EdgeLabelEnum edgeLabel,
772 JsonParseFlagEnum parseFlag) {
773 return getAdjacentVertices(parentVertex, edgeLabel, parseFlag, Direction.IN);
776 public Either<List<Vertex>, JanusGraphOperationStatus> getParentVertices(Vertex parentVertex, EdgeLabelEnum edgeLabel,
777 JsonParseFlagEnum parseFlag) {
778 return getAdjacentVertices(parentVertex, edgeLabel, parseFlag, Direction.IN);
781 private Either<List<Vertex>, JanusGraphOperationStatus> getAdjacentVertices(Vertex parentVertex, EdgeLabelEnum edgeLabel,
782 JsonParseFlagEnum parseFlag, Direction direction) {
783 List<Vertex> list = new ArrayList<>();
785 Either<JanusGraph, JanusGraphOperationStatus> graphRes = janusGraphClient.getGraph();
786 if (graphRes.isRight()) {
787 logger.error("Failed to retrieve graph. status is {}", graphRes);
788 return Either.right(graphRes.right().value());
790 Iterator<Edge> edgesCreatorIterator = parentVertex.edges(direction, edgeLabel.name());
791 if (edgesCreatorIterator != null) {
792 while (edgesCreatorIterator.hasNext()) {
793 Edge edge = edgesCreatorIterator.next();
794 JanusGraphVertex vertex;
795 if (direction == Direction.IN) {
796 vertex = (JanusGraphVertex) edge.outVertex();
798 vertex = (JanusGraphVertex) edge.inVertex();
800 // GraphVertex graphVertex = createAndFill(vertex, parseFlag);
804 if (list.isEmpty()) {
805 return Either.right(JanusGraphOperationStatus.NOT_FOUND);
807 } catch (Exception e) {
808 logger.error("Failed to perform graph operation ", e);
809 Either.right(JanusGraphClient.handleJanusGraphException(e));
811 return Either.left(list);
815 * @param parentVertex
820 public Either<List<Vertex>, JanusGraphOperationStatus> getChildrenVertices(Vertex parentVertex, EdgeLabelEnum edgeLabel,
821 JsonParseFlagEnum parseFlag) {
822 return getAdjacentVertices(parentVertex, edgeLabel, parseFlag, Direction.OUT);
825 private Either<List<GraphVertex>, JanusGraphOperationStatus> getAdjacentVertices(GraphVertex parentVertex, EdgeLabelEnum edgeLabel,
826 JsonParseFlagEnum parseFlag, Direction direction) {
827 List<GraphVertex> list = new ArrayList<>();
828 Either<List<Vertex>, JanusGraphOperationStatus> adjacentVerticies = getAdjacentVertices(parentVertex.getVertex(), edgeLabel, parseFlag,
830 if (adjacentVerticies.isRight()) {
831 return Either.right(adjacentVerticies.right().value());
833 adjacentVerticies.left().value().stream().forEach(vertex -> {
834 list.add(createAndFill((JanusGraphVertex) vertex, parseFlag));
836 return Either.left(list);
840 * Searches Edge by received label and criteria
845 * @return found edge or JanusGraphOperationStatus
847 public Either<Edge, JanusGraphOperationStatus> getBelongingEdgeByCriteria(GraphVertex vertex, EdgeLabelEnum label,
848 Map<GraphPropertyEnum, Object> properties) {
849 Either<Edge, JanusGraphOperationStatus> result = null;
850 Edge matchingEdge = null;
851 String notFoundMsg = "No edges in graph for criteria";
853 JanusGraphVertexQuery<?> query = vertex.getVertex().query().labels(label.name());
854 if (properties != null && !properties.isEmpty()) {
855 for (Map.Entry<GraphPropertyEnum, Object> entry : properties.entrySet()) {
856 query = query.has(entry.getKey().getProperty(), entry.getValue());
859 Iterable<JanusGraphEdge> edges = query.edges();
861 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, notFoundMsg);
862 result = Either.right(JanusGraphOperationStatus.NOT_FOUND);
864 Iterator<JanusGraphEdge> eIter = edges.iterator();
865 if (eIter.hasNext()) {
866 matchingEdge = eIter.next();
868 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, notFoundMsg);
869 result = Either.right(JanusGraphOperationStatus.NOT_FOUND);
872 if (result == null) {
873 result = Either.left(matchingEdge);
875 } catch (Exception e) {
876 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during getting edge by criteria for component with id {}. {}",
877 vertex.getUniqueId(), e);
878 return Either.right(JanusGraphClient.handleJanusGraphException(e));
883 public Either<Edge, JanusGraphOperationStatus> getEdgeByChildrenVertexProperties(GraphVertex vertex, EdgeLabelEnum label,
884 Map<GraphPropertyEnum, Object> properties) {
885 Either<Edge, JanusGraphOperationStatus> result = null;
886 Edge matchingEdge = null;
887 String notFoundMsg = "No edges in graph for criteria";
889 Iterator<Edge> edges = vertex.getVertex().edges(Direction.OUT, label.name());
890 while (edges.hasNext()) {
891 matchingEdge = edges.next();
892 Vertex childV = matchingEdge.inVertex();
893 Map<GraphPropertyEnum, Object> vertexProperties = getVertexProperties(childV);
894 Optional<Entry<GraphPropertyEnum, Object>> findNotMatch = properties.entrySet().stream()
895 .filter(e -> vertexProperties.get(e.getKey()) == null || !vertexProperties.get(e.getKey()).equals(e.getValue())).findFirst();
896 if (!findNotMatch.isPresent()) {
897 result = Either.left(matchingEdge);
900 if (result == null) {
902 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, notFoundMsg);
903 result = Either.right(JanusGraphOperationStatus.NOT_FOUND);
905 } catch (Exception e) {
906 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during getting edge by criteria for component with id {}. {}",
907 vertex.getUniqueId(), e);
908 return Either.right(JanusGraphClient.handleJanusGraphException(e));
914 * Deletes Edge by received label and criteria
921 public Either<Edge, JanusGraphOperationStatus> deleteBelongingEdgeByCriteria(GraphVertex vertex, EdgeLabelEnum label,
922 Map<GraphPropertyEnum, Object> properties) {
923 Either<Edge, JanusGraphOperationStatus> result = null;
925 result = getBelongingEdgeByCriteria(vertex, label, properties);
926 if (result.isLeft()) {
927 Edge edge = result.left().value();
929 .addRecordToLog(logger, LogLevelEnum.TRACE, "Going to delete an edge with the label {} belonging to the vertex {} ", label.name(),
930 vertex.getUniqueId());
932 result = Either.left(edge);
935 .addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to find an edge with the label {} belonging to the vertex {} ", label.name(),
936 vertex.getUniqueId());
938 } catch (Exception e) {
940 .addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occured during deleting an edge by criteria for the component with id {}. {}",
941 vertex == null ? "NULL" : vertex.getUniqueId(), e);
942 return Either.right(JanusGraphClient.handleJanusGraphException(e));
947 @SuppressWarnings("unchecked")
949 * Deletes an edge between vertices fromVertex and toVertex according to received label
956 public Either<Edge, JanusGraphOperationStatus> deleteEdge(GraphVertex fromVertex, GraphVertex toVertex, EdgeLabelEnum label) {
957 return deleteEdge(fromVertex.getVertex(), toVertex.getVertex(), label, fromVertex.getUniqueId(), toVertex.getUniqueId(), false);
960 public Either<Edge, JanusGraphOperationStatus> deleteAllEdges(GraphVertex fromVertex, GraphVertex toVertex, EdgeLabelEnum label) {
961 return deleteEdge(fromVertex.getVertex(), toVertex.getVertex(), label, fromVertex.getUniqueId(), toVertex.getUniqueId(), true);
964 public Either<Edge, JanusGraphOperationStatus> deleteEdge(JanusGraphVertex fromVertex, JanusGraphVertex toVertex, EdgeLabelEnum label,
965 String uniqueIdFrom, String uniqueIdTo, boolean deleteAll) {
966 Either<Edge, JanusGraphOperationStatus> result = null;
967 Vertex problemV = null;
969 Iterable<JanusGraphEdge> edges = fromVertex.query().labels(label.name()).edges();
970 Iterator<JanusGraphEdge> eIter = edges.iterator();
971 while (eIter.hasNext()) {
972 Edge edge = eIter.next();
973 problemV = edge.inVertex();
974 String currVertexUniqueId = null;
976 currVertexUniqueId = edge.inVertex().value(GraphPropertyEnum.UNIQUE_ID.getProperty());
977 } catch (Exception e) {
978 // AutoHealing procedure
979 logger.info("Corrupted vertex and edge were found and deleted {}", e);
980 if (problemV != null) {
981 Map<GraphPropertyEnum, Object> props = getVertexProperties(problemV);
982 logger.debug("problematic Vertex properties:");
983 logger.debug("props size: {}", props.size());
984 for (Map.Entry<GraphPropertyEnum, Object> entry : props.entrySet()) {
985 logger.debug("{}{}", entry.getKey() + ":" + entry.getValue());
987 Either<List<Vertex>, JanusGraphOperationStatus> childrenVertices = getChildrenVertices(problemV, EdgeLabelEnum.VERSION,
988 JsonParseFlagEnum.NoParse);
989 if (childrenVertices.isLeft()) {
990 childrenVertices.left().value().size();
991 logger.debug("number of children that problematic Vertex has: {}", props.size());
995 } catch (Exception e1) {
996 logger.debug("failed to remove problematic edge. {}", e1);
1000 } catch (Exception e2) {
1001 logger.debug("failed to remove problematic vertex . {}", e2);
1006 if (currVertexUniqueId != null && currVertexUniqueId.equals(uniqueIdTo)) {
1007 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to delete an edge with the label {} between vertices {} and {}. ",
1008 label.name(), uniqueIdFrom, uniqueIdTo);
1010 result = Either.left(edge);
1016 if (result == null) {
1017 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to delete an edge with the label {} between vertices {} and {}. ",
1018 label.name(), uniqueIdFrom, uniqueIdTo);
1019 result = Either.right(JanusGraphOperationStatus.NOT_FOUND);
1021 } catch (Exception e) {
1022 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG,
1023 "Exception occured during deleting an edge with the label {} between vertices {} and {}. {}", label.name(), uniqueIdFrom, uniqueIdTo,
1025 return Either.right(JanusGraphClient.handleJanusGraphException(e));
1030 public JanusGraphOperationStatus deleteEdgeByDirection(GraphVertex fromVertex, Direction direction, EdgeLabelEnum label) {
1032 Iterator<Edge> edges = fromVertex.getVertex().edges(direction, label.name());
1033 while (edges.hasNext()) {
1034 Edge edge = edges.next();
1037 } catch (Exception e) {
1038 logger.debug("Failed to remove from vertex {} edges {} by direction {} ", fromVertex.getUniqueId(), label, direction, e);
1039 return JanusGraphClient.handleJanusGraphException(e);
1041 return JanusGraphOperationStatus.OK;
1045 * Updates vertex properties. Note that graphVertex argument should contain updated data
1047 * @param graphVertex
1050 public Either<GraphVertex, JanusGraphOperationStatus> updateVertex(GraphVertex graphVertex) {
1051 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Going to update metadata of vertex with uniqueId {}. ", graphVertex.getUniqueId());
1053 graphVertex.updateMetadataJsonWithCurrentMetadataProperties();
1054 setVertexProperties(graphVertex.getVertex(), graphVertex);
1055 } catch (Exception e) {
1057 .addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to update metadata of vertex with uniqueId {}. ", graphVertex.getUniqueId(), e);
1058 return Either.right(JanusGraphClient.handleJanusGraphException(e));
1060 return Either.left(graphVertex);
1064 * Fetches vertices by uniqueId according to received parse flag
1066 * @param verticesToGet
1069 public Either<Map<String, GraphVertex>, JanusGraphOperationStatus> getVerticesByUniqueIdAndParseFlag(
1070 Map<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> verticesToGet) {
1071 Either<Map<String, GraphVertex>, JanusGraphOperationStatus> result = null;
1072 Map<String, GraphVertex> vertices = new HashMap<>();
1073 JanusGraphOperationStatus titatStatus;
1074 Either<GraphVertex, JanusGraphOperationStatus> getVertexRes = null;
1075 for (Map.Entry<String, ImmutablePair<GraphPropertyEnum, JsonParseFlagEnum>> entry : verticesToGet.entrySet()) {
1076 if (entry.getValue().getKey() == GraphPropertyEnum.UNIQUE_ID) {
1077 getVertexRes = getVertexById(entry.getKey(), entry.getValue().getValue());
1078 } else if (entry.getValue().getKey() == GraphPropertyEnum.USERID) {
1079 getVertexRes = getVertexByPropertyAndLabel(entry.getValue().getKey(), entry.getKey(), VertexTypeEnum.USER,
1080 entry.getValue().getValue());
1082 if (getVertexRes == null) {
1083 titatStatus = JanusGraphOperationStatus.ILLEGAL_ARGUMENT;
1085 .addRecordToLog(logger, LogLevelEnum.DEBUG, "Invalid vertex type label {} has been received. ", entry.getValue().getKey(),
1087 return Either.right(titatStatus);
1089 if (getVertexRes.isRight()) {
1090 titatStatus = getVertexRes.right().value();
1092 .addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to get vertex by id {} . Status is {}. ", entry.getKey(), titatStatus);
1093 result = Either.right(titatStatus);
1096 vertices.put(entry.getKey(), getVertexRes.left().value());
1099 if (result == null) {
1100 result = Either.left(vertices);
1106 * Creates edge between "from" and "to" vertices with specified label and properties extracted from received edge
1114 public JanusGraphOperationStatus createEdge(Vertex from, Vertex to, EdgeLabelEnum label, Edge edgeToCopy) {
1115 return createEdge(from, to, label, getEdgeProperties(edgeToCopy));
1118 public JanusGraphOperationStatus replaceEdgeLabel(Vertex fromVertex, Vertex toVertex, Edge prevEdge, EdgeLabelEnum prevLabel,
1119 EdgeLabelEnum newLabel) {
1121 .addRecordToLog(logger, LogLevelEnum.TRACE, "Going to replace edge with label {} to {} between vertices {} and {}", prevLabel, newLabel,
1122 fromVertex != null ? fromVertex.property(GraphPropertyEnum.UNIQUE_ID.getProperty()) : "NULL",
1123 toVertex != null ? toVertex.property(GraphPropertyEnum.UNIQUE_ID.getProperty()) : "NULL");
1124 JanusGraphOperationStatus result = createEdge(fromVertex, toVertex, newLabel, prevEdge);
1125 if (result == JanusGraphOperationStatus.OK) {
1132 * Replaces previous label of edge with new label
1140 public JanusGraphOperationStatus replaceEdgeLabel(Vertex fromVertex, Vertex toVertex, EdgeLabelEnum prevLabel, EdgeLabelEnum newLabel) {
1141 Iterator<Edge> prevEdgeIter = toVertex.edges(Direction.IN, prevLabel.name());
1142 if (prevEdgeIter == null || !prevEdgeIter.hasNext()) {
1144 .addRecordToLog(logger, LogLevelEnum.DEBUG, "Failed to replace edge with label {} to {} between vertices {} and {}", prevLabel,
1145 newLabel, fromVertex.property(GraphPropertyEnum.UNIQUE_ID.getProperty()),
1146 toVertex.property(GraphPropertyEnum.UNIQUE_ID.getProperty()));
1147 return JanusGraphOperationStatus.NOT_FOUND;
1149 return replaceEdgeLabel(fromVertex, toVertex, prevEdgeIter.next(), prevLabel, newLabel);
1154 * Updates metadata properties of vertex on graph. Json metadata property of the vertex will be updated with received properties too.
1160 public JanusGraphOperationStatus updateVertexMetadataPropertiesWithJson(Vertex vertex, Map<GraphPropertyEnum, Object> properties) {
1162 if (!MapUtils.isEmpty(properties)) {
1163 String jsonMetadataStr = (String) vertex.property(GraphPropertyEnum.METADATA.getProperty()).value();
1164 Map<String, Object> jsonMetadataMap = JsonParserUtils.toMap(jsonMetadataStr);
1165 for (Map.Entry<GraphPropertyEnum, Object> property : properties.entrySet()) {
1166 vertex.property(property.getKey().getProperty(), property.getValue());
1167 jsonMetadataMap.put(property.getKey().getProperty(), property.getValue());
1169 vertex.property(GraphPropertyEnum.METADATA.getProperty(), JsonParserUtils.toJson(jsonMetadataMap));
1171 } catch (Exception e) {
1172 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG, "Exception occurred during update vertex metadata properties with json{}. {}",
1173 vertex.property(GraphPropertyEnum.UNIQUE_ID.getProperty()), e.getMessage());
1174 return JanusGraphClient.handleJanusGraphException(e);
1176 return JanusGraphOperationStatus.OK;
1179 public JanusGraphOperationStatus disassociateAndDeleteLast(GraphVertex vertex, Direction direction, EdgeLabelEnum label) {
1181 Iterator<Edge> edges = vertex.getVertex().edges(direction, label.name());
1182 while (edges.hasNext()) {
1183 Edge edge = edges.next();
1184 Vertex secondVertex;
1185 Direction reverseDirection;
1186 if (direction == Direction.IN) {
1187 secondVertex = edge.outVertex();
1188 reverseDirection = Direction.OUT;
1190 secondVertex = edge.inVertex();
1191 reverseDirection = Direction.IN;
1194 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "Edge {} with direction {} was removed from {}", label.name(), direction,
1195 vertex.getVertex());
1196 Iterator<Edge> restOfEdges = secondVertex.edges(reverseDirection, label.name());
1197 if (!restOfEdges.hasNext()) {
1198 secondVertex.remove();
1199 CommonUtility.addRecordToLog(logger, LogLevelEnum.TRACE, "This was last edge . Vertex {} was removed ", vertex.getUniqueId());
1202 } catch (Exception e) {
1203 CommonUtility.addRecordToLog(logger, LogLevelEnum.DEBUG,
1204 "Exception occured during deleting an edge with the label {} direction {} from vertex {}. {}", label.name(), direction,
1205 vertex.getUniqueId(), e);
1206 return JanusGraphClient.handleJanusGraphException(e);
1208 return JanusGraphOperationStatus.OK;
1211 public Object getProperty(JanusGraphVertex vertex, String key) {
1212 PropertyKey propertyKey = janusGraphClient.getGraph().left().value().getPropertyKey(key);
1213 return vertex.valueOrNull(propertyKey);
1216 public Object getProperty(Edge edge, EdgePropertyEnum key) {
1217 Object value = null;
1219 Property<Object> property = edge.property(key.getProperty());
1220 if (property != null) {
1221 value = property.orElse(null);
1222 if (value != null && key == EdgePropertyEnum.INSTANCES) {
1223 return JsonParserUtils.toList((String) value, String.class);
1227 } catch (Exception e) {
1239 public JanusGraphOperationStatus moveEdge(GraphVertex vertexA, GraphVertex vertexB, EdgeLabelEnum label, Direction direction) {
1240 JanusGraphOperationStatus result = deleteEdgeByDirection(vertexA, direction, label);
1241 if (result != JanusGraphOperationStatus.OK) {
1242 logger.error("Failed to diassociate {} from element {}. error {} ", label, vertexA.getUniqueId(), result);
1245 JanusGraphOperationStatus createRelation;
1246 if (direction == Direction.IN) {
1247 createRelation = createEdge(vertexB, vertexA, label, null);
1249 createRelation = createEdge(vertexA, vertexB, label, null);
1251 if (createRelation != JanusGraphOperationStatus.OK) {
1252 return createRelation;
1254 return JanusGraphOperationStatus.OK;
1257 public Either<Edge, JanusGraphOperationStatus> getBelongingEdgeByCriteria(String parentId, EdgeLabelEnum label,
1258 Map<GraphPropertyEnum, Object> properties) {
1259 Either<GraphVertex, JanusGraphOperationStatus> getVertexRes = getVertexById(parentId, JsonParseFlagEnum.NoParse);
1260 if (getVertexRes.isRight()) {
1261 return Either.right(getVertexRes.right().value());
1263 return getBelongingEdgeByCriteria(getVertexRes.left().value(), label, properties);