catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.operations.impl;
  22
  23 import fj.data.Either;
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.Iterator;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Map.Entry;
  30 import java.util.Set;
  31 import java.util.stream.Collectors;
  32 import javax.annotation.Resource;
  33 import org.apache.commons.lang3.tuple.ImmutablePair;
  34 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
  35 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  36 import org.openecomp.sdc.be.dao.graph.datatype.GraphNode;
  37 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  38 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  39 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  40 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  41 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  42 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  45 import org.openecomp.sdc.be.model.ArtifactDefinition;
  46 import org.openecomp.sdc.be.model.InterfaceDefinition;
  47 import org.openecomp.sdc.be.model.Operation;
  48 import org.openecomp.sdc.be.model.normatives.ElementTypeEnum;
  49 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
  50 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  51 import org.openecomp.sdc.be.resources.data.ArtifactData;
  52 import org.openecomp.sdc.be.resources.data.InterfaceData;
  53 import org.openecomp.sdc.be.resources.data.ModelData;
  54 import org.openecomp.sdc.be.resources.data.OperationData;
  55 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  56 import org.openecomp.sdc.be.resources.data.UniqueIdData;
  57 import org.openecomp.sdc.common.log.wrappers.Logger;
  58 import org.springframework.stereotype.Component;
  59
  60 @Component("interface-operation")
  61 public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation {
  62
  63     private static final Logger log = Logger.getLogger(InterfaceLifecycleOperation.class.getName());
  64     private static final String FAILED_TO_FIND_OPERATION = "Failed to find operation  {} on interface {}";
  65     private static final String FAILED_TO_FIND_ARTIFACT = "Failed to add artifact {} to interface {}";
  66     @javax.annotation.Resource
  67     private ArtifactOperation artifactOperation;
  68     @javax.annotation.Resource
  69     private JanusGraphGenericDao janusGraphGenericDao;
  70     @Resource
  71     private ModelOperation modelOperation;
  72
  73     public InterfaceLifecycleOperation() {
  74         super();
  75     }
  76
  77     @Override
  78     public Either<InterfaceDefinition, StorageOperationStatus> addInterfaceToResource(InterfaceDefinition interf, String resourceId,
  79                                                                                       String interfaceName, boolean inTransaction) {
  80         return createInterfaceOnResource(interf, resourceId, interfaceName, true, inTransaction);
  81     }
  82
  83     private Either<OperationData, JanusGraphOperationStatus> addOperationToGraph(InterfaceDefinition interf, String opName, Operation op,
  84                                                                                  InterfaceData interfaceData) {
  85         op.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId((String) interfaceData.getUniqueId(), opName));
  86         OperationData operationData = new OperationData(op);
  87         log.debug("Before adding operation to graph {}", operationData);
  88         Either<OperationData, JanusGraphOperationStatus> createOpNodeResult = janusGraphGenericDao.createNode(operationData, OperationData.class);
  89         log.debug("After adding operation to graph {}", operationData);
  90         if (createOpNodeResult.isRight()) {
  91             JanusGraphOperationStatus opStatus = createOpNodeResult.right().value();
  92             log.error("Failed to add operation {} to graph. status is {}", opName, opStatus);
  93             return Either.right(opStatus);
  94         }
  95         Map<String, Object> props = new HashMap<>();
  96         props.put(GraphPropertiesDictionary.NAME.getProperty(), opName);
  97         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
  98             .createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props);
  99         if (createRelResult.isRight()) {
 100             JanusGraphOperationStatus operationStatus = createOpNodeResult.right().value();
 101             log.error("Failed to associate operation {} to property {} in graph. status is {}", interfaceData.getUniqueId(), opName, operationStatus);
 102             return Either.right(operationStatus);
 103         }
 104         return Either.left(createOpNodeResult.left().value());
 105     }
 106
 107     private InterfaceDefinition convertInterfaceDataToInterfaceDefinition(InterfaceData interfaceData) {
 108         log.debug("The object returned after create interface is {}", interfaceData);
 109         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition(interfaceData.getInterfaceDataDefinition());
 110         interfaceDefinition.setModel(getModelAssociatedToInterface(interfaceData.getUniqueId()));
 111         return interfaceDefinition;
 112     }
 113
 114     private Operation convertOperationDataToOperation(OperationData operationData) {
 115         log.debug("The object returned after create operation is {}", operationData);
 116         return new Operation(operationData.getOperationDataDefinition());
 117     }
 118
 119     private Either<InterfaceData, JanusGraphOperationStatus> addInterfaceToGraph(InterfaceDefinition interfaceInfo, String interfaceName,
 120                                                                                  String resourceId) {
 121         InterfaceData interfaceData = new InterfaceData(interfaceInfo);
 122         ResourceMetadataData resourceData = new ResourceMetadataData();
 123         resourceData.getMetadataDataDefinition().setUniqueId(resourceId);
 124         String interfaceNameSplitted = getShortInterfaceName(interfaceInfo);
 125         interfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted));
 126         Either<InterfaceData, JanusGraphOperationStatus> existInterface = janusGraphGenericDao
 127             .getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class);
 128         if (existInterface.isRight()) {
 129             return createInterfaceNodeAndRelation(interfaceNameSplitted, resourceId, interfaceData, resourceData);
 130         } else {
 131             log.debug("Interface {} already exist", interfaceData.getUniqueId());
 132             return Either.right(JanusGraphOperationStatus.ALREADY_EXIST);
 133         }
 134     }
 135
 136     private Either<InterfaceData, JanusGraphOperationStatus> createInterfaceNodeAndRelation(String interfaceName, String resourceId,
 137                                                                                             InterfaceData interfaceData,
 138                                                                                             ResourceMetadataData resourceData) {
 139         log.debug("Before adding interface to graph {}", interfaceData);
 140         Either<InterfaceData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao.createNode(interfaceData, InterfaceData.class);
 141         log.debug("After adding property to graph {}", interfaceData);
 142         if (createNodeResult.isRight()) {
 143             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 144             log.error("Failed to add interface {} to graph. status is {}", interfaceName, operationStatus);
 145             return Either.right(operationStatus);
 146         }
 147         Map<String, Object> props = new HashMap<>();
 148         props.put(GraphPropertiesDictionary.NAME.getProperty(), interfaceName);
 149         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 150             .createRelation(resourceData, interfaceData, GraphEdgeLabels.INTERFACE, props);
 151         if (createRelResult.isRight()) {
 152             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 153             log.error("Failed to associate resource {} to property {} in graph. status is {}", resourceId, interfaceName, operationStatus);
 154             return Either.right(operationStatus);
 155         }
 156         return Either.left(createNodeResult.left().value());
 157     }
 158
 159     private Either<OperationData, JanusGraphOperationStatus> createOperationNodeAndRelation(String operationName, OperationData operationData,
 160                                                                                             InterfaceData interfaceData) {
 161         log.debug("Before adding operation to graph {}", operationData);
 162         Either<OperationData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao.createNode(operationData, OperationData.class);
 163         log.debug("After adding operation to graph {}", interfaceData);
 164         if (createNodeResult.isRight()) {
 165             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 166             log.error("Failed to add interfoperationce {} to graph. status is {}", operationName, operationStatus);
 167             return Either.right(operationStatus);
 168         }
 169         Map<String, Object> props = new HashMap<>();
 170         props.put(GraphPropertiesDictionary.NAME.getProperty(), operationName);
 171         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 172             .createRelation(interfaceData, operationData, GraphEdgeLabels.INTERFACE_OPERATION, props);
 173         if (createRelResult.isRight()) {
 174             JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 175             log.error("Failed to associate operation {} to interface {} in graph. status is {}", operationName, interfaceData.getUniqueId(),
 176                 operationStatus);
 177             return Either.right(operationStatus);
 178         }
 179         return Either.left(createNodeResult.left().value());
 180     }
 181
 182     @Override
 183     public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfacesOfResource(String resourceIdn, boolean recursively) {
 184         return getAllInterfacesOfResource(resourceIdn, recursively, false);
 185     }
 186
 187     @Override
 188     public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfacesOfResource(String resourceId, boolean recursively,
 189                                                                                                        boolean inTransaction) {
 190         Either<Map<String, InterfaceDefinition>, StorageOperationStatus> result = null;
 191         Map<String, InterfaceDefinition> interfaces = new HashMap<>();
 192         try {
 193             if ((resourceId == null) || resourceId.isEmpty()) {
 194                 log.error("resourceId is empty");
 195                 result = Either.right(StorageOperationStatus.INVALID_ID);
 196                 return result;
 197             }
 198             JanusGraphOperationStatus findInterfacesRes = JanusGraphOperationStatus.GENERAL_ERROR;
 199             if (recursively) {
 200                 findInterfacesRes = findAllInterfacesRecursively(resourceId, interfaces);
 201             } else {
 202                 findInterfacesRes = findAllInterfacesNotRecursively(resourceId, interfaces);
 203             }
 204             if (!findInterfacesRes.equals(JanusGraphOperationStatus.OK)) {
 205                 log.error("Failed to get all interfaces of resource {}. status is {}", resourceId, findInterfacesRes);
 206                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(findInterfacesRes));
 207                 return result;
 208             }
 209             result = Either.left(interfaces);
 210             return result;
 211         } finally {
 212             if (!inTransaction) {
 213                 if (result == null || result.isRight()) {
 214                     log.error("Going to execute rollback on graph.");
 215                     janusGraphGenericDao.rollback();
 216                 } else {
 217                     log.debug("Going to execute commit on graph.");
 218                     janusGraphGenericDao.commit();
 219                 }
 220             }
 221         }
 222     }
 223
 224     private JanusGraphOperationStatus findAllInterfacesNotRecursively(String resourceId, Map<String, InterfaceDefinition> interfaces) {
 225         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> interfaceNodes = janusGraphGenericDao
 226             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface,
 227                 InterfaceData.class);
 228         if (interfaceNodes.isRight()) {
 229             JanusGraphOperationStatus status = interfaceNodes.right().value();
 230             if (status != JanusGraphOperationStatus.NOT_FOUND) {
 231                 return status;
 232             }
 233         } else {
 234             List<ImmutablePair<InterfaceData, GraphEdge>> interfaceList = interfaceNodes.left().value();
 235             if (interfaceList != null) {
 236                 for (ImmutablePair<InterfaceData, GraphEdge> interfacePair : interfaceList) {
 237                     String interfaceUniqueId = (String) interfacePair.getKey().getUniqueId();
 238                     Either<String, JanusGraphOperationStatus> interfaceNameRes = getPropertyValueFromEdge(interfacePair.getValue(),
 239                         GraphPropertiesDictionary.NAME);
 240                     if (interfaceNameRes.isRight()) {
 241                         log.error("The requirement name is missing on the edge of requirement {}", interfaceUniqueId);
 242                         return interfaceNameRes.right().value();
 243                     }
 244                     String interfaceName = interfaceNameRes.left().value();
 245                     Either<InterfaceDefinition, JanusGraphOperationStatus> interfaceDefRes = getNonRecursiveInterface(interfacePair.getKey());
 246                     if (interfaceDefRes.isRight()) {
 247                         JanusGraphOperationStatus status = interfaceDefRes.right().value();
 248                         log.error("Failed to get interface actions of interface {}", interfaceUniqueId);
 249                         return status;
 250                     }
 251                     InterfaceDefinition interfaceDefinition = interfaceDefRes.left().value();
 252                     if (interfaces.containsKey(interfaceName)) {
 253                         log.debug("The interface {} was already defined in dervied resource. add not overriden operations", interfaceName);
 254                         InterfaceDefinition existInterface = interfaces.get(interfaceName);
 255                         addMissingOperationsToInterface(interfaceDefinition, existInterface);
 256                     } else {
 257                         interfaces.put(interfaceName, interfaceDefinition);
 258                     }
 259                 }
 260             }
 261         }
 262         return JanusGraphOperationStatus.OK;
 263     }
 264
 265     public JanusGraphOperationStatus findAllInterfacesRecursively(String resourceId, Map<String, InterfaceDefinition> interfaces) {
 266         JanusGraphOperationStatus findAllInterfacesNotRecursively = findAllInterfacesNotRecursively(resourceId, interfaces);
 267         if (!findAllInterfacesNotRecursively.equals(JanusGraphOperationStatus.OK)) {
 268             log.error("failed to get interfaces for resource {}. status is {}", resourceId, findAllInterfacesNotRecursively);
 269         }
 270         Either<ImmutablePair<ResourceMetadataData, GraphEdge>, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao
 271             .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
 272                 ResourceMetadataData.class);
 273         if (parentNodes.isRight()) {
 274             JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value();
 275             if (parentNodesStatus == JanusGraphOperationStatus.NOT_FOUND) {
 276                 log.debug("Finish to lookup for parnet interfaces");
 277                 return JanusGraphOperationStatus.OK;
 278             } else {
 279                 log.error("Failed to find parent interfaces of resource {}. status is {}", resourceId, parentNodesStatus);
 280                 return parentNodesStatus;
 281             }
 282         }
 283         ImmutablePair<ResourceMetadataData, GraphEdge> parentNodePair = parentNodes.left().value();
 284         String parentUniqueId = parentNodePair.getKey().getMetadataDataDefinition().getUniqueId();
 285         JanusGraphOperationStatus addParentIntStatus = findAllInterfacesRecursively(parentUniqueId, interfaces);
 286         if (addParentIntStatus != JanusGraphOperationStatus.OK) {
 287             log.error("Failed to fetch all interfaces of resource {}", parentUniqueId);
 288             return addParentIntStatus;
 289         }
 290         return JanusGraphOperationStatus.OK;
 291     }
 292
 293     private Either<String, JanusGraphOperationStatus> getPropertyValueFromEdge(GraphEdge edge, GraphPropertiesDictionary property) {
 294         Map<String, Object> edgeProps = edge.getProperties();
 295         String interfaceName = null;
 296         if (edgeProps != null) {
 297             interfaceName = (String) edgeProps.get(property.getProperty());
 298             if (interfaceName == null) {
 299                 return Either.right(JanusGraphOperationStatus.INVALID_ELEMENT);
 300             }
 301         } else {
 302             return Either.right(JanusGraphOperationStatus.INVALID_ELEMENT);
 303         }
 304         return Either.left(interfaceName);
 305     }
 306
 307     private Either<InterfaceDefinition, JanusGraphOperationStatus> getNonRecursiveInterface(InterfaceData interfaceData) {
 308         log.debug("Going to fetch the operations associate to interface {}", interfaceData.getUniqueId());
 309         InterfaceDefinition interfaceDefinition = new InterfaceDefinition(interfaceData.getInterfaceDataDefinition());
 310         String interfaceId = interfaceData.getUniqueId();
 311         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationsRes = janusGraphGenericDao
 312             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceId, GraphEdgeLabels.INTERFACE_OPERATION,
 313                 NodeTypeEnum.InterfaceOperation, OperationData.class);
 314         if (operationsRes.isRight()) {
 315             JanusGraphOperationStatus status = operationsRes.right().value();
 316             if (status != JanusGraphOperationStatus.NOT_FOUND) {
 317                 return Either.right(status);
 318             } else {
 319                 return Either.left(interfaceDefinition);
 320             }
 321         }
 322         List<ImmutablePair<OperationData, GraphEdge>> operationList = operationsRes.left().value();
 323         if (operationList != null && !operationList.isEmpty()) {
 324             for (ImmutablePair<OperationData, GraphEdge> operationPair : operationList) {
 325                 Operation operation = new Operation(operationPair.getKey().getOperationDataDefinition());
 326                 Either<String, JanusGraphOperationStatus> operationNameRes = getPropertyValueFromEdge(operationPair.getValue(),
 327                     GraphPropertiesDictionary.NAME);
 328                 if (operationNameRes.isRight()) {
 329                     log.error("The operation name is missing on the edge of operation {}", operationPair.getKey().getUniqueId());
 330                     return Either.right(operationNameRes.right().value());
 331                 }
 332                 String operationName = operationNameRes.left().value();
 333                 findOperationImplementation(operation);
 334                 interfaceDefinition.getOperations().put(operationName, operation);
 335             }
 336         }
 337         return Either.left(interfaceDefinition);
 338     }
 339
 340     private StorageOperationStatus findOperationImplementation(Operation operation) {
 341         String operationId = operation.getUniqueId();
 342         Either<Map<String, ArtifactDefinition>, StorageOperationStatus> artifactsRes = artifactOperation
 343             .getArtifacts(operationId, NodeTypeEnum.InterfaceOperation, true);
 344         if (artifactsRes.isRight() || artifactsRes.left().value() == null) {
 345             log.error("failed to get artifact from graph for operation id {}. status is {}", operationId, artifactsRes.right().value());
 346             return artifactsRes.right().value();
 347         } else {
 348             Map<String, ArtifactDefinition> artifacts = artifactsRes.left().value();
 349             Iterator<String> iter = artifacts.keySet().iterator();
 350             if (iter.hasNext()) {
 351                 operation.setImplementation(artifacts.get(iter.next()));
 352             }
 353         }
 354         return StorageOperationStatus.OK;
 355     }
 356
 357     private StorageOperationStatus addMissingOperationsToInterface(InterfaceDefinition interfaceDefinition, InterfaceDefinition existInterface) {
 358         Map<String, Operation> existOperations = existInterface.getOperationsMap();
 359         Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
 360         if (operations != null && !operations.isEmpty()) {
 361             Set<Entry<String, Operation>> operationsSet = operations.entrySet();
 362             for (Entry<String, Operation> operation : operationsSet) {
 363                 if (!existOperations.containsKey(operation.getKey())) {
 364                     existOperations.put(operation.getKey(), operation.getValue());
 365                 }
 366             }
 367         }
 368         return StorageOperationStatus.OK;
 369     }
 370
 371     @Override
 372     public Either<Operation, StorageOperationStatus> updateInterfaceOperation(String resourceId, String interfaceName, String operationName,
 373                                                                               Operation interf) {
 374         return updateInterfaceOperation(resourceId, interfaceName, operationName, interf, false);
 375     }
 376
 377     @Override
 378     public Either<Operation, StorageOperationStatus> updateInterfaceOperation(String resourceId, String interfaceName, String operationName,
 379                                                                               Operation operation, boolean inTransaction) {
 380         return updateOperationOnGraph(operation, resourceId, interfaceName, operationName);
 381     }
 382
 383     private Either<Operation, StorageOperationStatus> updateOperationOnGraph(Operation operation, String resourceId, String interfaceName,
 384                                                                              String operationName) {
 385         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 386             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface,
 387                 InterfaceData.class);
 388         if (childrenNodes.isRight()) {
 389             return updateOperationFromParentNode(operation, resourceId, interfaceName, operationName);
 390         } else {
 391             return updateExistingOperation(resourceId, operation, interfaceName, operationName, childrenNodes);
 392         }
 393     }
 394
 395     private Either<Operation, StorageOperationStatus> updateExistingOperation(String resourceId, Operation operation, String interfaceName,
 396                                                                               String operationName,
 397                                                                               Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes) {
 398         Operation newOperation = null;
 399         StorageOperationStatus storageOperationStatus = StorageOperationStatus.GENERAL_ERROR;
 400         for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
 401             GraphEdge interfaceEdge = interfaceDataNode.getRight();
 402             Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
 403             InterfaceData interfaceData = interfaceDataNode.getKey();
 404             if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceName)) {
 405                 Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao
 406                     .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(),
 407                         GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 408                 if (operationRes.isRight()) {
 409                     log.error(FAILED_TO_FIND_OPERATION, operationName, interfaceName);
 410                     return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 411                 } else {
 412                     List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
 413                     for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
 414                         GraphEdge opEdge = operationPairEdge.getRight();
 415                         OperationData opData = operationPairEdge.getLeft();
 416                         Map<String, Object> opEdgeProp = opEdge.getProperties();
 417                         if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
 418                             ArtifactDefinition artifact = operation.getImplementationArtifact();
 419                             Either<ImmutablePair<ArtifactData, GraphEdge>, JanusGraphOperationStatus> artifactRes = janusGraphGenericDao
 420                                 .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) opData.getUniqueId(),
 421                                     GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class);
 422                             Either<ArtifactDefinition, StorageOperationStatus> artStatus;
 423                             if (artifactRes.isRight()) {
 424                                 artStatus = artifactOperation.addArifactToComponent(artifact, (String) operationPairEdge.getLeft().getUniqueId(),
 425                                     NodeTypeEnum.InterfaceOperation, true, true);
 426                             } else {
 427                                 artStatus = artifactOperation.updateArifactOnResource(artifact, (String) operationPairEdge.getLeft().getUniqueId(),
 428                                     (String) artifactRes.left().value().getLeft().getUniqueId(), NodeTypeEnum.InterfaceOperation, true);
 429                             }
 430                             if (artStatus.isRight()) {
 431                                 janusGraphGenericDao.rollback();
 432                                 log.error(FAILED_TO_FIND_ARTIFACT, operationName, interfaceName);
 433                                 return Either.right(artStatus.right().value());
 434                             } else {
 435                                 newOperation = this.convertOperationDataToOperation(opData);
 436                                 newOperation.setImplementation(artStatus.left().value());
 437                             }
 438                         }
 439                     }
 440                     if (newOperation == null) {
 441                         Either<InterfaceData, JanusGraphOperationStatus> parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName);
 442                         if (parentInterfaceStatus.isRight()) {
 443                             log.debug("Interface {} not exist", interfaceName);
 444                             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentInterfaceStatus.right().value()));
 445                         }
 446                         InterfaceData parentInterfaceData = parentInterfaceStatus.left().value();
 447                         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> opRes = janusGraphGenericDao
 448                             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) parentInterfaceData.getUniqueId(),
 449                                 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 450                         if (opRes.isRight()) {
 451                             log.error(FAILED_TO_FIND_OPERATION, operationName, interfaceName);
 452                             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 453                         } else {
 454                             List<ImmutablePair<OperationData, GraphEdge>> parentOperations = opRes.left().value();
 455                             for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : parentOperations) {
 456                                 GraphEdge opEdge = operationPairEdge.getRight();
 457                                 OperationData opData = operationPairEdge.getLeft();
 458                                 Map<String, Object> opEdgeProp = opEdge.getProperties();
 459                                 if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
 460                                     return copyAndCreateNewOperation(operation, interfaceName, operationName, null, interfaceData, operationRes,
 461                                         opData);
 462                                 }
 463                             }
 464                         }
 465                     }
 466                 }
 467             } else {
 468                 // not found
 469                 storageOperationStatus = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 470             }
 471         }
 472         if (newOperation == null) {
 473             return Either.right(storageOperationStatus);
 474         } else {
 475             return Either.left(newOperation);
 476         }
 477     }
 478
 479     private Either<Operation, StorageOperationStatus> copyAndCreateNewOperation(Operation operation, String interfaceName, String operationName,
 480                                                                                 Operation newOperation, InterfaceData interfaceData,
 481                                                                                 Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes,
 482                                                                                 OperationData opData) {
 483         OperationDataDefinition opDataInfo = opData.getOperationDataDefinition();
 484         OperationDataDefinition newOperationInfo = new OperationDataDefinition(opDataInfo);
 485         newOperationInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(interfaceData.getUniqueId(), operationName.toLowerCase()));
 486         OperationData newopData = new OperationData(newOperationInfo);
 487         Either<OperationData, JanusGraphOperationStatus> operationStatus = createOperationNodeAndRelation(operationName, newopData, interfaceData);
 488         if (operationStatus.isRight()) {
 489             log.error("Failed to create operation  {} on interface {}", operationName, interfaceName);
 490             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 491         }
 492         ArtifactDefinition artifact = operation.getImplementationArtifact();
 493         if (artifact != null) {
 494             Either<ArtifactDefinition, StorageOperationStatus> artStatus = artifactOperation
 495                 .addArifactToComponent(artifact, (String) operationStatus.left().value().getUniqueId(), NodeTypeEnum.InterfaceOperation, true, true);
 496             if (artStatus.isRight()) {
 497                 janusGraphGenericDao.rollback();
 498                 log.error(FAILED_TO_FIND_ARTIFACT, operationName, interfaceName);
 499             } else {
 500                 newOperation = this.convertOperationDataToOperation(opData);
 501                 newOperation.setImplementation(artStatus.left().value());
 502             }
 503         }
 504         return Either.left(newOperation);
 505     }
 506
 507     private Either<Operation, StorageOperationStatus> updateOperationFromParentNode(Operation operation, String resourceId, String interfaceName,
 508                                                                                     String operationName) {
 509         // Operation newOperation = null;
 510         ResourceMetadataData resourceData = new ResourceMetadataData();
 511         resourceData.getMetadataDataDefinition().setUniqueId(resourceId);
 512         Either<InterfaceData, JanusGraphOperationStatus> parentInterfaceStatus = findInterfaceOnParentNode(resourceId, interfaceName);
 513         if (parentInterfaceStatus.isRight()) {
 514             log.debug("Interface {} not exist", interfaceName);
 515             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(parentInterfaceStatus.right().value()));
 516         }
 517         InterfaceData interfaceData = parentInterfaceStatus.left().value();
 518         InterfaceDataDefinition intDataDefinition = interfaceData.getInterfaceDataDefinition();
 519         InterfaceDataDefinition newInterfaceInfo = new InterfaceDataDefinition(intDataDefinition);
 520         String interfaceNameSplitted = getShortInterfaceName(intDataDefinition);
 521         newInterfaceInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, interfaceNameSplitted));
 522         InterfaceData updatedInterfaceData = new InterfaceData(newInterfaceInfo);
 523         Either<InterfaceData, JanusGraphOperationStatus> createStatus = createInterfaceNodeAndRelation(interfaceName, resourceId,
 524             updatedInterfaceData, resourceData);
 525         if (createStatus.isRight()) {
 526             log.debug("failed to create interface node  {} on resource  {}", interfaceName, resourceId);
 527             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(createStatus.right().value()));
 528         }
 529         InterfaceData newInterfaceNode = createStatus.left().value();
 530         Either<GraphRelation, JanusGraphOperationStatus> createRelResult = janusGraphGenericDao
 531             .createRelation(newInterfaceNode, interfaceData, GraphEdgeLabels.DERIVED_FROM, null);
 532         if (createRelResult.isRight()) {
 533             JanusGraphOperationStatus operationStatus = createRelResult.right().value();
 534             log.error("Failed to associate interface {} to interface {} in graph. status is {}", interfaceData.getUniqueId(),
 535                 newInterfaceNode.getUniqueId(), operationStatus);
 536             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus));
 537         }
 538         Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao
 539             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceData.getUniqueId(),
 540                 GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 541         if (operationRes.isRight()) {
 542             log.error(FAILED_TO_FIND_OPERATION, operationName, interfaceName);
 543             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationRes.right().value()));
 544         } else {
 545             List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
 546             for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
 547                 GraphEdge opEdge = operationPairEdge.getRight();
 548                 OperationData opData = operationPairEdge.getLeft();
 549                 Map<String, Object> opEdgeProp = opEdge.getProperties();
 550                 if (opEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(operationName)) {
 551                     return copyAndCreateNewOperation(operation, interfaceName, operationName, null, // changed
 552
 553                         // from
 554
 555                         // newOperation
 556                         newInterfaceNode, operationRes, opData);
 557                 }
 558             }
 559         }
 560         return Either.right(StorageOperationStatus.GENERAL_ERROR);
 561     }
 562
 563     private Either<InterfaceData, JanusGraphOperationStatus> findInterfaceOnParentNode(String resourceId, String interfaceName) {
 564         Either<ImmutablePair<ResourceMetadataData, GraphEdge>, JanusGraphOperationStatus> parentRes = janusGraphGenericDao
 565             .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
 566                 ResourceMetadataData.class);
 567         if (parentRes.isRight()) {
 568             log.debug("interface {} not found ", interfaceName);
 569             return Either.right(parentRes.right().value());
 570         }
 571         ImmutablePair<ResourceMetadataData, GraphEdge> parenNode = parentRes.left().value();
 572         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 573             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), parenNode.getKey().getMetadataDataDefinition().getUniqueId(),
 574                 GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface, InterfaceData.class);
 575         if (childrenNodes.isRight()) {
 576             return findInterfaceOnParentNode(parenNode.getKey().getMetadataDataDefinition().getUniqueId(), interfaceName);
 577         } else {
 578             for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
 579                 GraphEdge interfaceEdge = interfaceDataNode.getRight();
 580                 Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
 581                 if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceName)) {
 582                     return Either.left(interfaceDataNode.getKey());
 583                 }
 584             }
 585             return findInterfaceOnParentNode(parenNode.getKey().getMetadataDataDefinition().getUniqueId(), interfaceName);
 586         }
 587     }
 588
 589     @Override
 590     public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceOnResource(InterfaceDefinition interf, String resourceId,
 591                                                                                          String interfaceName, boolean failIfExist,
 592                                                                                          boolean inTransaction) {
 593         Either<InterfaceData, JanusGraphOperationStatus> status = addInterfaceToGraph(interf, interfaceName, resourceId);
 594         if (status.isRight()) {
 595             janusGraphGenericDao.rollback();
 596             log.error("Failed to add interface {} to resource {}", interfaceName, resourceId);
 597             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status.right().value()));
 598         } else {
 599             if (!inTransaction) {
 600                 janusGraphGenericDao.commit();
 601             }
 602             InterfaceData interfaceData = status.left().value();
 603             InterfaceDefinition interfaceDefResult = convertInterfaceDataToInterfaceDefinition(interfaceData);
 604             Map<String, Operation> operations = interf.getOperationsMap();
 605             if (operations != null && !operations.isEmpty()) {
 606                 Set<String> opNames = operations.keySet();
 607                 Map<String, Operation> newOperations = new HashMap<>();
 608                 for (String operationName : opNames) {
 609                     Operation op = operations.get(operationName);
 610                     Either<OperationData, JanusGraphOperationStatus> opStatus = addOperationToGraph(interf, operationName, op, interfaceData);
 611                     if (status.isRight()) {
 612                         janusGraphGenericDao.rollback();
 613                         log.error("Failed to add operation {} to interface {}", operationName, interfaceName);
 614                     } else if (status.isLeft()) {
 615                         if (!inTransaction) {
 616                             janusGraphGenericDao.commit();
 617                         }
 618                         OperationData opData = opStatus.left().value();
 619                         Operation newOperation = this.convertOperationDataToOperation(opData);
 620                         ArtifactDefinition art = op.getImplementationArtifact();
 621                         if (art != null) {
 622                             Either<ArtifactDefinition, StorageOperationStatus> artRes = artifactOperation
 623                                 .addArifactToComponent(art, (String) opData.getUniqueId(), NodeTypeEnum.InterfaceOperation, failIfExist, true);
 624                             if (artRes.isRight()) {
 625                                 janusGraphGenericDao.rollback();
 626                                 log.error(FAILED_TO_FIND_ARTIFACT, operationName, interfaceName);
 627                             } else {
 628                                 newOperation.setImplementation(artRes.left().value());
 629                             }
 630                             newOperations.put(operationName, newOperation);
 631                         }
 632                     }
 633                 }
 634                 interfaceDefResult.setOperationsMap(newOperations);
 635             }
 636             log.debug("The returned InterfaceDefintion is {}", interfaceDefResult);
 637             return Either.left(interfaceDefResult);
 638         }
 639     }
 640
 641     @Override
 642     public Either<Operation, StorageOperationStatus> deleteInterfaceOperation(String resourceId, String interfaceName, String operationId,
 643                                                                               boolean inTransaction) {
 644         Either<Operation, JanusGraphOperationStatus> status = removeOperationOnGraph(resourceId, interfaceName, operationId);
 645         if (status.isRight()) {
 646             if (!inTransaction) {
 647                 janusGraphGenericDao.rollback();
 648             }
 649             log.error("Failed to delete operation {} of interface {} resource {}", operationId, interfaceName, resourceId);
 650             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status.right().value()));
 651         } else {
 652             if (!inTransaction) {
 653                 janusGraphGenericDao.commit();
 654             }
 655             Operation opDefResult = status.left().value();
 656             log.debug("The returned Operation is {}", opDefResult);
 657             return Either.left(opDefResult);
 658         }
 659     }
 660
 661     private Either<Operation, JanusGraphOperationStatus> removeOperationOnGraph(String resourceId, String interfaceName, String operationId) {
 662         log.debug("Before deleting operation from graph {}", operationId);
 663         Either<List<ImmutablePair<InterfaceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 664             .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), resourceId, GraphEdgeLabels.INTERFACE, NodeTypeEnum.Interface,
 665                 InterfaceData.class);
 666         if (childrenNodes.isRight()) {
 667             log.debug("Not found interface {}", interfaceName);
 668             return Either.right(childrenNodes.right().value());
 669         }
 670         OperationData opData = null;
 671         for (ImmutablePair<InterfaceData, GraphEdge> interfaceDataNode : childrenNodes.left().value()) {
 672             GraphEdge interfaceEdge = interfaceDataNode.getRight();
 673             Map<String, Object> interfaceEdgeProp = interfaceEdge.getProperties();
 674             String interfaceSplitedName = splitType(interfaceName);
 675             if (interfaceEdgeProp.get(GraphPropertiesDictionary.NAME.getProperty()).equals(interfaceSplitedName)) {
 676                 Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> operationRes = janusGraphGenericDao
 677                     .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) interfaceDataNode.getLeft().getUniqueId(),
 678                         GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 679                 if (operationRes.isRight()) {
 680                     log.error("Failed to find operation {} on interface {}", operationId, interfaceName);
 681                     return Either.right(operationRes.right().value());
 682                 }
 683                 List<ImmutablePair<OperationData, GraphEdge>> operations = operationRes.left().value();
 684                 for (ImmutablePair<OperationData, GraphEdge> operationPairEdge : operations) {
 685                     opData = operationPairEdge.getLeft();
 686                     if (opData.getUniqueId().equals(operationId)) {
 687                         Either<ImmutablePair<ArtifactData, GraphEdge>, JanusGraphOperationStatus> artifactRes = janusGraphGenericDao
 688                             .getChild(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), (String) operationPairEdge.getLeft().getUniqueId(),
 689                                 GraphEdgeLabels.ARTIFACT_REF, NodeTypeEnum.ArtifactRef, ArtifactData.class);
 690                         Either<ArtifactDefinition, StorageOperationStatus> arStatus = null;
 691                         if (artifactRes.isLeft()) {
 692                             ArtifactData arData = artifactRes.left().value().getKey();
 693                             arStatus = artifactOperation
 694                                 .removeArifactFromResource((String) operationPairEdge.getLeft().getUniqueId(), (String) arData.getUniqueId(),
 695                                     NodeTypeEnum.InterfaceOperation, true, true);
 696                             if (arStatus.isRight()) {
 697                                 log.debug("failed to delete artifact {}", arData.getUniqueId());
 698                                 return Either.right(JanusGraphOperationStatus.INVALID_ID);
 699                             }
 700                         }
 701                         Either<OperationData, JanusGraphOperationStatus> deleteOpStatus = janusGraphGenericDao
 702                             .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.InterfaceOperation), opData.getUniqueId(), OperationData.class);
 703                         if (deleteOpStatus.isRight()) {
 704                             log.debug("failed to delete operation {}", opData.getUniqueId());
 705                             return Either.right(JanusGraphOperationStatus.INVALID_ID);
 706                         }
 707                         opData = deleteOpStatus.left().value();
 708                         Operation operation = new Operation(opData.getOperationDataDefinition());
 709                         if (arStatus != null) {
 710                             operation.setImplementation(arStatus.left().value());
 711                         }
 712                         if (operations.size() <= 1) {
 713                             Either<InterfaceData, JanusGraphOperationStatus> deleteInterfaceStatus = janusGraphGenericDao
 714                                 .deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceDataNode.left.getUniqueId(),
 715                                     InterfaceData.class);
 716                             if (deleteInterfaceStatus.isRight()) {
 717                                 log.debug("failed to delete interface {}", interfaceDataNode.left.getUniqueId());
 718                                 return Either.right(JanusGraphOperationStatus.INVALID_ID);
 719                             }
 720                         }
 721                         return Either.left(operation);
 722                     }
 723                 }
 724             }
 725         }
 726         log.debug("Not found operation {}", interfaceName);
 727         return Either.right(JanusGraphOperationStatus.INVALID_ID);
 728     }
 729
 730     private String splitType(String interfaceName) {
 731         String interfaceSplittedName;
 732         String[] packageName = interfaceName.split("\\.");
 733         if (packageName.length == 0) {
 734             interfaceSplittedName = interfaceName;
 735         } else {
 736             interfaceSplittedName = packageName[packageName.length - 1];
 737         }
 738         return interfaceSplittedName.toLowerCase();
 739     }
 740
 741     /**
 742      * FOR TEST ONLY
 743      *
 744      * @param janusGraphGenericDao
 745      */
 746     public void setJanusGraphGenericDao(JanusGraphGenericDao janusGraphGenericDao) {
 747         this.janusGraphGenericDao = janusGraphGenericDao;
 748     }
 749
 750     public void setArtifactOperation(ArtifactOperation artifactOperation) {
 751         this.artifactOperation = artifactOperation;
 752     }
 753
 754     @Override
 755     public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceType(InterfaceDefinition interf, boolean inTransaction) {
 756         Either<InterfaceDefinition, StorageOperationStatus> result = null;
 757         try {
 758             interf.setUniqueId(UniqueIdBuilder.buildInterfaceTypeUid(interf.getModel(), interf.getType()));
 759             InterfaceData interfaceData = new InterfaceData(interf);
 760             Either<InterfaceData, JanusGraphOperationStatus> existInterface = janusGraphGenericDao
 761                 .getNode(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), InterfaceData.class);
 762             if (existInterface.isLeft()) {
 763                 // already exist
 764                 log.debug("Interface type already exist {}", interfaceData);
 765                 result = Either.right(StorageOperationStatus.ENTITY_ALREADY_EXISTS);
 766                 return result;
 767             }
 768             Either<InterfaceData, JanusGraphOperationStatus> createNodeResult = janusGraphGenericDao.createNode(interfaceData, InterfaceData.class);
 769             log.debug("After adding property type to graph {}", interfaceData);
 770             if (createNodeResult.isRight()) {
 771                 JanusGraphOperationStatus operationStatus = createNodeResult.right().value();
 772                 log.error("Failed to add interface {} to graph. status is {}", interf.getType(), operationStatus);
 773                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(operationStatus));
 774                 return result;
 775             }
 776             InterfaceDefinition interfaceDefResult = convertInterfaceDataToInterfaceDefinition(interfaceData);
 777             Map<String, Operation> operations = interf.getOperationsMap();
 778             if (operations != null && !operations.isEmpty()) {
 779                 Map<String, Operation> newOperations = new HashMap<>();
 780                 for (Map.Entry<String, Operation> operation : operations.entrySet()) {
 781                     Either<OperationData, JanusGraphOperationStatus> opStatus = addOperationToGraph(interf, operation.getKey(), operation.getValue(),
 782                         interfaceData);
 783                     if (opStatus.isRight()) {
 784                         janusGraphGenericDao.rollback();
 785                         log.error("Failed to add operation {} to interface {}", operation.getKey(), interf.getType());
 786                         result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(opStatus.right().value()));
 787                         return result;
 788                     } else {
 789                         OperationData opData = opStatus.left().value();
 790                         Operation newOperation = this.convertOperationDataToOperation(opData);
 791                         newOperations.put(operation.getKey(), newOperation);
 792                     }
 793                 }
 794                 interfaceDefResult.setOperationsMap(newOperations);
 795             }
 796             final Either<GraphRelation, StorageOperationStatus> modelRelationship = addInterfaceTypeToModel(interf);
 797             if (modelRelationship.isRight()) {
 798                 return Either.right(modelRelationship.right().value());
 799             }
 800
 801             result = Either.left(interfaceDefResult);
 802             return result;
 803         } finally {
 804             if (!inTransaction) {
 805                 if (result == null || result.isRight()) {
 806                     log.error("Going to execute rollback on graph.");
 807                     janusGraphGenericDao.rollback();
 808                 } else {
 809                     log.debug("Going to execute commit on graph.");
 810                     janusGraphGenericDao.commit();
 811                 }
 812             }
 813         }
 814     }
 815
 816     private Either<GraphRelation, StorageOperationStatus> addInterfaceTypeToModel(final InterfaceDefinition interfaceDefinition) {
 817         final String model = interfaceDefinition.getModel();
 818         if (model == null) {
 819             return Either.left(null);
 820         }
 821         final GraphNode from = new UniqueIdData(NodeTypeEnum.Model, UniqueIdBuilder.buildModelUid(model));
 822         final GraphNode to = new UniqueIdData(NodeTypeEnum.Interface, interfaceDefinition.getUniqueId());
 823         log.info("Connecting model {} to type {}", from, to);
 824         return janusGraphGenericDao.createRelation(from, to, GraphEdgeLabels.MODEL_ELEMENT, Collections.emptyMap()).right()
 825             .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 826     }
 827
 828     @Override
 829     public Either<InterfaceDefinition, StorageOperationStatus> getInterface(String interfaceId) {
 830         Either<InterfaceData, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 831             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), interfaceId, InterfaceData.class);
 832         if (getResult.isLeft()) {
 833             InterfaceData interfaceData = getResult.left().value();
 834             return Either.left(convertInterfaceDataToInterfaceDefinition(interfaceData));
 835         } else {
 836             JanusGraphOperationStatus janusGraphStatus = getResult.right().value();
 837             log.debug("Node with id {} was not found in the graph. status: {}", interfaceId, janusGraphStatus);
 838             StorageOperationStatus storageOperationStatus = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(janusGraphStatus);
 839             return Either.right(storageOperationStatus);
 840         }
 841     }
 842
 843     public String getShortInterfaceName(InterfaceDataDefinition interfaceDefinition) {
 844         String[] packageName = interfaceDefinition.getType().split("\\.");
 845         String interfaceName;
 846         if (packageName.length == 0) {
 847             interfaceName = interfaceDefinition.getType();
 848         } else {
 849             interfaceName = packageName[packageName.length - 1];
 850         }
 851         return interfaceName.toLowerCase();
 852     }
 853
 854     public Either<InterfaceDefinition, StorageOperationStatus> createInterfaceType(InterfaceDefinition interf) {
 855         return createInterfaceType(interf, false);
 856     }
 857
 858     @Override
 859     public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfaceLifecycleTypes(final String model) {
 860         Either<List<InterfaceData>, JanusGraphOperationStatus> allInterfaceLifecycleTypes = janusGraphGenericDao
 861             .getByCriteriaForModel(NodeTypeEnum.Interface, Collections.emptyMap(), model, InterfaceData.class);
 862         if (allInterfaceLifecycleTypes.isRight()) {
 863             return Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(allInterfaceLifecycleTypes.right().value()));
 864         }
 865         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 866         List<InterfaceData> interfaceDataList = allInterfaceLifecycleTypes.left().value();
 867         List<InterfaceDefinition> interfaceDefinitions = interfaceDataList.stream().map(this::convertInterfaceDataToInterfaceDefinition)
 868             .filter(interfaceDefinition -> interfaceDefinition.getUniqueId()
 869                 .equalsIgnoreCase(UniqueIdBuilder.buildInterfaceTypeUid(interfaceDefinition.getModel(), interfaceDefinition.getType()))
 870             ).collect(Collectors.toList());
 871         for (InterfaceDefinition interfaceDefinition : interfaceDefinitions) {
 872             Either<List<ImmutablePair<OperationData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 873                 .getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceDefinition.getUniqueId(),
 874                     GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class);
 875             if (childrenNodes.isLeft()) {
 876                 Map<String, OperationDataDefinition> operationsDataDefinitionMap = new HashMap<>();
 877                 for (ImmutablePair<OperationData, GraphEdge> operation : childrenNodes.left().value()) {
 878                     OperationData operationData = operation.getLeft();
 879                     operationsDataDefinitionMap.put(operationData.getUniqueId(), operationData.getOperationDataDefinition());
 880                 }
 881                 interfaceDefinition.setOperations(operationsDataDefinitionMap);
 882             }
 883             interfaceTypes.put(interfaceDefinition.getUniqueId(), interfaceDefinition);
 884         }
 885         return Either.left(interfaceTypes);
 886     }
 887
 888     private String getModelAssociatedToInterface(String uid) {
 889         final Either<ImmutablePair<ModelData, GraphEdge>, JanusGraphOperationStatus> model = janusGraphGenericDao.getParentNode(
 890             UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Interface), uid, GraphEdgeLabels.MODEL_ELEMENT,
 891             NodeTypeEnum.Model, ModelData.class);
 892         if (model.isLeft()) {
 893             return model.left().value().getLeft().getName();
 894         }
 895         return null;
 896     }
 897
 898     public void deleteInterfaceTypeById(String interfaceTypeId) {
 899         try (final GraphTraversalSource traversal = janusGraphGenericDao.getJanusGraph().traversal()) {
 900             traversal.V()
 901                 .has(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceTypeId)
 902                 .out(GraphEdgeLabels.INTERFACE_OPERATION.getProperty())
 903                 .toList()
 904                 .forEach(interfaceOperationVertex -> {
 905                     traversal.V(interfaceOperationVertex).out(GraphEdgeLabels.PROPERTY.getProperty()).drop().iterate();
 906                     interfaceOperationVertex.remove();
 907                 });
 908             traversal.V().has(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), interfaceTypeId).toList()
 909                 .forEach(interfaceTypeVertex -> {
 910                     traversal.V(interfaceTypeVertex).out(GraphEdgeLabels.PROPERTY.getProperty()).drop().iterate();
 911                     interfaceTypeVertex.remove();
 912                 });
 913         } catch (Exception e) {
 914             log.error("Failed to delete interface type {} and interface operations in graph. {}", interfaceTypeId, e);
 915         }
 916     }
 917
 918     public void removeInterfaceTypeFromAdditionalType(InterfaceDefinition interfaceDefinition) {
 919         modelOperation.removeTypeFromAdditionalType(ElementTypeEnum.INTERFACE_LIFECYCLE_TYPE, interfaceDefinition.getModel(),
 920             interfaceDefinition.getType());
 921     }
 922 }