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