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