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