catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/AdditionalInformationOperation.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 fj.data.Either;
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Map.Entry;
  28 import org.apache.commons.lang3.tuple.ImmutablePair;
  29 import org.apache.tinkerpop.gremlin.structure.Vertex;
  30 import org.janusgraph.core.JanusGraphVertex;
  31 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  32 import org.openecomp.sdc.be.dao.graph.GraphElementFactory;
  33 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  34 import org.openecomp.sdc.be.dao.graph.datatype.GraphElementTypeEnum;
  35 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  36 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  37 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  38 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  39 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  40 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
  41 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo;
  42 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  43 import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
  44 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  45 import org.openecomp.sdc.be.resources.data.AdditionalInfoParameterData;
  46 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  47 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
  48 import org.openecomp.sdc.be.resources.data.UniqueIdData;
  49 import org.openecomp.sdc.common.log.wrappers.Logger;
  50 import org.springframework.stereotype.Component;
  51
  52 @Component("additional-information-operation")
  53 public class AdditionalInformationOperation {
  54
  55     public static final String EMPTY_VALUE = null;
  56     private static final Logger log = Logger.getLogger(AdditionalInformationOperation.class.getName());
  57     private static final String GOING_TO_EXECUTE_COMMIT_ON_GRAPH = "Going to execute commit on graph.";
  58     private static final String GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH = "Going to execute rollback on graph.";
  59     private static final String ADDITIONAL_INFORMATION_OF = "additional information of ";
  60     @javax.annotation.Resource
  61     private JanusGraphGenericDao janusGraphGenericDao;
  62
  63     public AdditionalInformationOperation() {
  64         super();
  65     }
  66
  67     public Either<AdditionalInformationDefinition, JanusGraphOperationStatus> addAdditionalInformationParameter(NodeTypeEnum nodeType,
  68                                                                                                                 String componentId, String key,
  69                                                                                                                 String value) {
  70         JanusGraphOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId);
  71         if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) {
  72             return Either.right(verifyNodeTypeVsComponent);
  73         }
  74         Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> getResult = janusGraphGenericDao
  75             .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
  76                 NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
  77         if (getResult.isRight()) {
  78             JanusGraphOperationStatus status = getResult.right().value();
  79             return Either.right(status);
  80         }
  81         ImmutablePair<AdditionalInfoParameterData, GraphEdge> immutablePair = getResult.left().value();
  82         AdditionalInfoParameterData parameterData = immutablePair.getLeft();
  83         Map<String, String> parameters = parameterData.getParameters();
  84         if (parameters == null) {
  85             parameters = new HashMap<>();
  86             parameterData.setParameters(parameters);
  87         }
  88         Map<String, String> idToKey = parameterData.getIdToKey();
  89         if (idToKey == null) {
  90             idToKey = new HashMap<>();
  91             parameterData.setIdToKey(idToKey);
  92         }
  93         Integer lastCreatedCounter = parameterData.getAdditionalInfoParameterDataDefinition().getLastCreatedCounter();
  94         lastCreatedCounter++;
  95         if (parameters.containsKey(key)) {
  96             log.debug("The key {} already exists under component {}", key, componentId);
  97             return Either.right(JanusGraphOperationStatus.ALREADY_EXIST);
  98         }
  99         idToKey.put(String.valueOf(lastCreatedCounter), key);
 100         parameters.put(key, value);
 101         parameterData.getAdditionalInfoParameterDataDefinition().setLastCreatedCounter(lastCreatedCounter);
 102         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
 103             .updateNode(parameterData, AdditionalInfoParameterData.class);
 104         if (updateNode.isRight()) {
 105             JanusGraphOperationStatus status = updateNode.right().value();
 106             BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("UpdateAdditionalInformationParameter",
 107                 ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status));
 108             return Either.right(status);
 109         }
 110         AdditionalInformationDefinition informationDefinition = createInformationDefinitionFromNode(componentId, parameters, idToKey,
 111             updateNode.left().value());
 112         return Either.left(informationDefinition);
 113     }
 114
 115     public Either<AdditionalInformationDefinition, JanusGraphOperationStatus> updateAdditionalInformationParameter(NodeTypeEnum nodeType,
 116                                                                                                                    String componentId, String id,
 117                                                                                                                    String key, String value) {
 118         JanusGraphOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId);
 119         if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) {
 120             return Either.right(verifyNodeTypeVsComponent);
 121         }
 122         Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 123             .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
 124                 NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
 125         if (getResult.isRight()) {
 126             JanusGraphOperationStatus status = getResult.right().value();
 127             return Either.right(status);
 128         }
 129         ImmutablePair<AdditionalInfoParameterData, GraphEdge> immutablePair = getResult.left().value();
 130         AdditionalInfoParameterData parameterData = immutablePair.getLeft();
 131         Map<String, String> parameters = parameterData.getParameters();
 132         Map<String, String> idToKey = parameterData.getIdToKey();
 133         if (idToKey == null || !idToKey.containsKey(id)) {
 134             return Either.right(JanusGraphOperationStatus.INVALID_ID);
 135         }
 136         String origKey = idToKey.get(id);
 137         if (!origKey.equals(key)) {
 138             if (parameters.containsKey(key)) {
 139                 log.debug("The key {} already exists", key);
 140                 return Either.right(JanusGraphOperationStatus.ALREADY_EXIST);
 141             }
 142             String removed = parameters.remove(origKey);
 143             log.trace("The key-value {} = {} was removed from additionalInformation", origKey, removed);
 144         }
 145         parameters.put(key, value);
 146         idToKey.put(id, key);
 147         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
 148             .updateNode(parameterData, AdditionalInfoParameterData.class);
 149         if (updateNode.isRight()) {
 150             JanusGraphOperationStatus status = updateNode.right().value();
 151             BeEcompErrorManager.getInstance()
 152                 .logBeFailedUpdateNodeError("UpdateAdditionalInformationParameter", "additional information of resource " + componentId,
 153                     String.valueOf(status));
 154             return Either.right(status);
 155         }
 156         AdditionalInformationDefinition informationDefinition = createInformationDefinitionFromNode(componentId, parameters, idToKey,
 157             updateNode.left().value());
 158         return Either.left(informationDefinition);
 159     }
 160
 161     public Either<AdditionalInformationDefinition, JanusGraphOperationStatus> deleteAdditionalInformationParameter(NodeTypeEnum nodeType,
 162                                                                                                                    String componentId, String id) {
 163         JanusGraphOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId);
 164         if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) {
 165             return Either.right(verifyNodeTypeVsComponent);
 166         }
 167         Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 168             .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
 169                 NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
 170         if (getResult.isRight()) {
 171             JanusGraphOperationStatus status = getResult.right().value();
 172             return Either.right(status);
 173         }
 174         ImmutablePair<AdditionalInfoParameterData, GraphEdge> immutablePair = getResult.left().value();
 175         AdditionalInfoParameterData parameterData = immutablePair.getLeft();
 176         Map<String, String> parameters = parameterData.getParameters();
 177         Map<String, String> idToKey = parameterData.getIdToKey();
 178         if (idToKey == null || !idToKey.containsKey(id)) {
 179             return Either.right(JanusGraphOperationStatus.INVALID_ID);
 180         }
 181         String key = idToKey.get(id);
 182         String removedKey = idToKey.remove(id);
 183         String removedValue = parameters.remove(key);
 184         log.trace("The key-value {} = {} was removed from additionalInformation", removedKey, removedValue);
 185         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
 186             .updateNode(parameterData, AdditionalInfoParameterData.class);
 187         if (updateNode.isRight()) {
 188             JanusGraphOperationStatus status = updateNode.right().value();
 189             BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("DeleteAdditionalInformationParameter",
 190                 ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status));
 191             return Either.right(status);
 192         }
 193         AdditionalInformationDefinition informationDefinition = createInformationDefinitionFromNode(componentId, parameters, idToKey,
 194             updateNode.left().value());
 195         return Either.left(informationDefinition);
 196     }
 197
 198     private AdditionalInformationDefinition createInformationDefinitionFromNode(String resourceId, Map<String, String> parameters,
 199                                                                                 Map<String, String> idToKey,
 200                                                                                 AdditionalInfoParameterData additionalInfoParameterData) {
 201         AdditionalInfoParameterDataDefinition dataDefinition = additionalInfoParameterData.getAdditionalInfoParameterDataDefinition();
 202         return new AdditionalInformationDefinition(dataDefinition, resourceId, convertParameters(parameters, idToKey));
 203     }
 204
 205     private List<AdditionalInfoParameterInfo> convertParameters(Map<String, String> parameters, Map<String, String> idToKey) {
 206         List<AdditionalInfoParameterInfo> list = new ArrayList<>();
 207         if (parameters != null) {
 208             for (Entry<String, String> idToKeyEntry : idToKey.entrySet()) {
 209                 String id = idToKeyEntry.getKey();
 210                 String key = idToKeyEntry.getValue();
 211                 String value = parameters.get(key);
 212                 AdditionalInfoParameterInfo parameterInfo = new AdditionalInfoParameterInfo(id, key, value);
 213                 list.add(parameterInfo);
 214             }
 215         }
 216         return list;
 217     }
 218
 219     public Either<AdditionalInfoParameterData, JanusGraphOperationStatus> addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId) {
 220         UniqueIdData from = new UniqueIdData(nodeType, componentId);
 221         String uniqueId = UniqueIdBuilder.buildAdditionalInformationUniqueId(componentId);
 222         AdditionalInfoParameterDataDefinition additionalInfoParameterDataDefinition = new AdditionalInfoParameterDataDefinition();
 223         additionalInfoParameterDataDefinition.setUniqueId(uniqueId);
 224         AdditionalInfoParameterData additionalInfoParameterData = new AdditionalInfoParameterData(additionalInfoParameterDataDefinition,
 225             new HashMap<>(), new HashMap<>());
 226         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> createNode = janusGraphGenericDao
 227             .createNode(additionalInfoParameterData, AdditionalInfoParameterData.class);
 228         if (createNode.isRight()) {
 229             JanusGraphOperationStatus status = createNode.right().value();
 230             BeEcompErrorManager.getInstance().logBeFailedCreateNodeError("AddAdditionalInformationNode", uniqueId, String.valueOf(status));
 231             return Either.right(status);
 232         }
 233         AdditionalInfoParameterData to = createNode.left().value();
 234         Either<GraphRelation, JanusGraphOperationStatus> createRelation = janusGraphGenericDao
 235             .createRelation(from, to, GraphEdgeLabels.ADDITIONAL_INFORMATION, null);
 236         if (createRelation.isRight()) {
 237             JanusGraphOperationStatus status = createRelation.right().value();
 238             return Either.right(status);
 239         }
 240         return Either.left(to);
 241     }
 242
 243     public Either<JanusGraphVertex, JanusGraphOperationStatus> addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId,
 244                                                                                             JanusGraphVertex metadataVertex) {
 245         String uniqueId = UniqueIdBuilder.buildAdditionalInformationUniqueId(componentId);
 246         AdditionalInfoParameterDataDefinition additionalInfoParameterDataDefinition = new AdditionalInfoParameterDataDefinition();
 247         additionalInfoParameterDataDefinition.setUniqueId(uniqueId);
 248         AdditionalInfoParameterData additionalInfoParameterData = new AdditionalInfoParameterData(additionalInfoParameterDataDefinition,
 249             new HashMap<>(), new HashMap<>());
 250         Either<JanusGraphVertex, JanusGraphOperationStatus> createNode = janusGraphGenericDao.createNode(additionalInfoParameterData);
 251         if (createNode.isRight()) {
 252             JanusGraphOperationStatus status = createNode.right().value();
 253             BeEcompErrorManager.getInstance().logBeFailedCreateNodeError("AddAdditionalInformationNode", uniqueId, String.valueOf(status));
 254             return Either.right(status);
 255         }
 256         JanusGraphVertex additionalInfoVertex = createNode.left().value();
 257         JanusGraphOperationStatus createRelation = janusGraphGenericDao
 258             .createEdge(metadataVertex, additionalInfoVertex, GraphEdgeLabels.ADDITIONAL_INFORMATION, null);
 259         if (!createRelation.equals(JanusGraphOperationStatus.OK)) {
 260             return Either.right(createRelation);
 261         }
 262         return Either.left(additionalInfoVertex);
 263     }
 264
 265     public Either<AdditionalInformationDefinition, JanusGraphOperationStatus> addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId,
 266                                                                                                            AdditionalInformationDefinition parameters) {
 267         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> status = this.addAdditionalInformationNode(nodeType, componentId);
 268         if (status.isRight()) {
 269             return Either.right(status.right().value());
 270         }
 271         AdditionalInfoParameterData parameterData = status.left().value();
 272         populateParameterNodeWithParameters(parameterData, parameters);
 273         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
 274             .updateNode(parameterData, AdditionalInfoParameterData.class);
 275         if (updateNode.isRight()) {
 276             return Either.right(updateNode.right().value());
 277         }
 278         AdditionalInformationDefinition informationDefinition = convertAdditionalInformationDataToDefinition(updateNode.left().value(), componentId);
 279         return Either.left(informationDefinition);
 280     }
 281
 282     public JanusGraphOperationStatus addAdditionalInformationNode(NodeTypeEnum nodeType, String componentId,
 283                                                                   AdditionalInformationDefinition parameters, JanusGraphVertex metadataVertex) {
 284         Either<JanusGraphVertex, JanusGraphOperationStatus> status = this.addAdditionalInformationNode(nodeType, componentId, metadataVertex);
 285         if (status.isRight()) {
 286             return status.right().value();
 287         }
 288         JanusGraphVertex additionalInfoVertex = status.left().value();
 289         Map<String, Object> newProp = janusGraphGenericDao.getProperties(additionalInfoVertex);
 290         AdditionalInfoParameterData parameterData = GraphElementFactory
 291             .createElement(NodeTypeEnum.AdditionalInfoParameters.getName(), GraphElementTypeEnum.Node, newProp, AdditionalInfoParameterData.class);
 292         populateParameterNodeWithParameters(parameterData, parameters);
 293         return janusGraphGenericDao.updateVertex(parameterData, additionalInfoVertex);
 294     }
 295
 296     private void populateParameterNodeWithParameters(AdditionalInfoParameterData parameterData, AdditionalInformationDefinition aiDefinition) {
 297         if (aiDefinition != null) {
 298             Integer lastCreatedCounter = aiDefinition.getLastCreatedCounter();
 299             parameterData.getAdditionalInfoParameterDataDefinition().setLastCreatedCounter(lastCreatedCounter);
 300             log.trace("Set last created counter of additional information to {}", lastCreatedCounter);
 301             List<AdditionalInfoParameterInfo> parameters = aiDefinition.getParameters();
 302             if (parameters != null) {
 303                 Map<String, String> idToKey = new HashMap<>();
 304                 Map<String, String> parametersMap = new HashMap<>();
 305                 for (AdditionalInfoParameterInfo additionalInfoParameterInfo : parameters) {
 306                     String uniqueId = additionalInfoParameterInfo.getUniqueId();
 307                     String key = additionalInfoParameterInfo.getKey();
 308                     String value = additionalInfoParameterInfo.getValue();
 309                     if (key != null && !key.isEmpty()) {
 310                         idToKey.put(uniqueId, key);
 311                         parametersMap.put(key, value);
 312                     }
 313                 }
 314                 parameterData.setIdToKey(idToKey);
 315                 parameterData.setParameters(parametersMap);
 316             }
 317         }
 318     }
 319
 320     public JanusGraphOperationStatus findResourceAllAdditionalInformationRecursively(String uniqueId,
 321                                                                                      List<AdditionalInformationDefinition> properties) {
 322         log.trace("Going to fetch additional information under resource {}", uniqueId);
 323         JanusGraphOperationStatus resourceCapabilitiesStatus = findAdditionalInformationOfNode(NodeTypeEnum.Resource, uniqueId, properties);
 324         if (!resourceCapabilitiesStatus.equals(JanusGraphOperationStatus.OK)) {
 325             return resourceCapabilitiesStatus;
 326         }
 327         Either<ImmutablePair<ResourceMetadataData, GraphEdge>, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao
 328             .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Resource), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Resource,
 329                 ResourceMetadataData.class);
 330         if (parentNodes.isRight()) {
 331             JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value();
 332             if (!parentNodesStatus.equals(JanusGraphOperationStatus.NOT_FOUND)) {
 333                 log.error("Failed to find parent additional information of resource {}. status is {}", uniqueId, parentNodesStatus);
 334                 return parentNodesStatus;
 335             }
 336         }
 337         if (parentNodes.isLeft()) {
 338             ImmutablePair<ResourceMetadataData, GraphEdge> parnetNodePair = parentNodes.left().value();
 339             String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId();
 340             JanusGraphOperationStatus addParentIntStatus = findResourceAllAdditionalInformationRecursively(parentUniqueId, properties);
 341             if (addParentIntStatus != JanusGraphOperationStatus.OK) {
 342                 log.error("Failed to find all resource additional information of resource {}", parentUniqueId);
 343                 return addParentIntStatus;
 344             }
 345         }
 346         return JanusGraphOperationStatus.OK;
 347     }
 348
 349     public JanusGraphOperationStatus findServiceAllAdditionalInformationRecursively(String uniqueId,
 350                                                                                     List<AdditionalInformationDefinition> properties) {
 351         log.trace("Going to fetch additional information under service {}", uniqueId);
 352         JanusGraphOperationStatus resourceCapabilitiesStatus = findAdditionalInformationOfNode(NodeTypeEnum.Service, uniqueId, properties);
 353         if (!resourceCapabilitiesStatus.equals(JanusGraphOperationStatus.OK)) {
 354             return resourceCapabilitiesStatus;
 355         }
 356         Either<ImmutablePair<ServiceMetadataData, GraphEdge>, JanusGraphOperationStatus> parentNodes = janusGraphGenericDao
 357             .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Service), uniqueId, GraphEdgeLabels.DERIVED_FROM, NodeTypeEnum.Service,
 358                 ServiceMetadataData.class);
 359         if (parentNodes.isRight()) {
 360             JanusGraphOperationStatus parentNodesStatus = parentNodes.right().value();
 361             if (!parentNodesStatus.equals(JanusGraphOperationStatus.NOT_FOUND)) {
 362                 log.error("Failed to find parent additional information of resource {}. status is {}", uniqueId, parentNodesStatus);
 363                 return parentNodesStatus;
 364             }
 365         }
 366         if (parentNodes.isLeft()) {
 367             ImmutablePair<ServiceMetadataData, GraphEdge> parnetNodePair = parentNodes.left().value();
 368             String parentUniqueId = parnetNodePair.getKey().getMetadataDataDefinition().getUniqueId();
 369             JanusGraphOperationStatus addParentIntStatus = findServiceAllAdditionalInformationRecursively(parentUniqueId, properties);
 370             if (addParentIntStatus != JanusGraphOperationStatus.OK) {
 371                 log.error("Failed to find all resource additional information of resource {}", parentUniqueId);
 372                 return addParentIntStatus;
 373             }
 374         }
 375         return JanusGraphOperationStatus.OK;
 376     }
 377
 378     private JanusGraphOperationStatus findAdditionalInformationOfNode(NodeTypeEnum nodeType, String uniqueId,
 379                                                                       List<AdditionalInformationDefinition> properties) {
 380         Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> childNode = janusGraphGenericDao
 381             .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), uniqueId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
 382                 NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
 383         if (childNode.isRight()) {
 384             JanusGraphOperationStatus status = childNode.right().value();
 385             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 386                 status = JanusGraphOperationStatus.OK;
 387             }
 388             return status;
 389         }
 390         ImmutablePair<AdditionalInfoParameterData, GraphEdge> immutablePair = childNode.left().value();
 391         AdditionalInfoParameterData propertyData = immutablePair.getKey();
 392         Map<String, String> parameters = propertyData.getParameters();
 393         if (parameters != null && !parameters.isEmpty()) {
 394             AdditionalInformationDefinition additionalInfoDef = this.convertAdditionalInformationDataToDefinition(propertyData, uniqueId);
 395             properties.add(additionalInfoDef);
 396         }
 397         return JanusGraphOperationStatus.OK;
 398     }
 399
 400     private AdditionalInformationDefinition convertAdditionalInformationDataToDefinition(AdditionalInfoParameterData additionalInfoData,
 401                                                                                          String uniqueId) {
 402         Map<String, String> parameters = additionalInfoData.getParameters();
 403         Map<String, String> idToKey = additionalInfoData.getIdToKey();
 404         return new AdditionalInformationDefinition(additionalInfoData.getAdditionalInfoParameterDataDefinition(), uniqueId,
 405             convertParameters(parameters, idToKey));
 406     }
 407
 408     public Either<AdditionalInformationDefinition, StorageOperationStatus> createAdditionalInformationParameter(NodeTypeEnum nodeType,
 409                                                                                                                 String resourceId, String key,
 410                                                                                                                 String value, boolean inTransaction) {
 411         Either<AdditionalInformationDefinition, StorageOperationStatus> result = null;
 412         try {
 413             Either<AdditionalInformationDefinition, JanusGraphOperationStatus> either = this
 414                 .addAdditionalInformationParameter(nodeType, resourceId, key, value);
 415             if (either.isRight()) {
 416                 JanusGraphOperationStatus status = either.right().value();
 417                 log.debug("Failed to add additional information property {} to component {}. Status is {}", key, resourceId, status);
 418                 BeEcompErrorManager.getInstance().logBeFailedUpdateNodeError("CreateAdditionalInformationParameter",
 419                     ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + resourceId, String.valueOf(status));
 420                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
 421             } else {
 422                 AdditionalInformationDefinition additionalInformationDefinition = either.left().value();
 423                 result = Either.left(additionalInformationDefinition);
 424             }
 425             return result;
 426         } finally {
 427             commitOrRollback(inTransaction, result);
 428         }
 429     }
 430
 431     public Either<AdditionalInformationDefinition, StorageOperationStatus> updateAdditionalInformationParameter(NodeTypeEnum nodeType,
 432                                                                                                                 String resourceId, String id,
 433                                                                                                                 String key, String value,
 434                                                                                                                 boolean inTransaction) {
 435         Either<AdditionalInformationDefinition, StorageOperationStatus> result = null;
 436         try {
 437             Either<AdditionalInformationDefinition, JanusGraphOperationStatus> either = this
 438                 .updateAdditionalInformationParameter(nodeType, resourceId, id, key, value);
 439             if (either.isRight()) {
 440                 log.info("Failed to update additional information property {} to component {}", key, resourceId);
 441                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value()));
 442             } else {
 443                 AdditionalInformationDefinition additionalInformationDefinition = either.left().value();
 444                 result = Either.left(additionalInformationDefinition);
 445             }
 446             return result;
 447         } finally {
 448             commitOrRollback(inTransaction, result);
 449         }
 450     }
 451
 452     public Either<AdditionalInformationDefinition, StorageOperationStatus> deleteAdditionalInformationParameter(NodeTypeEnum nodeType,
 453                                                                                                                 String resourceId, String id,
 454                                                                                                                 boolean inTransaction) {
 455         Either<AdditionalInformationDefinition, StorageOperationStatus> result = null;
 456         try {
 457             Either<AdditionalInformationDefinition, JanusGraphOperationStatus> either = this
 458                 .deleteAdditionalInformationParameter(nodeType, resourceId, id);
 459             if (either.isRight()) {
 460                 log.error("Failed to delete additional information id {} to component {}", id, resourceId);
 461                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value()));
 462             } else {
 463                 AdditionalInformationDefinition additionalInformationDefinition = either.left().value();
 464                 result = Either.left(additionalInformationDefinition);
 465             }
 466             return result;
 467         } finally {
 468             commitOrRollback(inTransaction, result);
 469         }
 470     }
 471
 472     public Either<Integer, StorageOperationStatus> getNumberOfAdditionalInformationParameters(NodeTypeEnum nodeType, String resourceId,
 473                                                                                               boolean inTransaction) {
 474         Either<Integer, StorageOperationStatus> result = null;
 475         try {
 476             Either<Integer, JanusGraphOperationStatus> either = this.getNumberOfParameters(nodeType, resourceId);
 477             if (either.isRight()) {
 478                 log.error("Failed to get the number of additional information properties in component {}", resourceId);
 479                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value()));
 480             } else {
 481                 Integer counter = either.left().value();
 482                 result = Either.left(counter);
 483             }
 484             return result;
 485         } finally {
 486             if (!inTransaction) {
 487                 if (result == null || result.isRight()) {
 488                     log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH);
 489                     janusGraphGenericDao.rollback();
 490                 } else {
 491                     log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH);
 492                     janusGraphGenericDao.commit();
 493                 }
 494             }
 495         }
 496     }
 497
 498     public Either<Integer, JanusGraphOperationStatus> getNumberOfParameters(NodeTypeEnum nodeType, String resourceId) {
 499         Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 500             .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), resourceId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
 501                 NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
 502         if (getResult.isRight()) {
 503             JanusGraphOperationStatus status = getResult.right().value();
 504             return Either.right(status);
 505         }
 506         ImmutablePair<AdditionalInfoParameterData, GraphEdge> immutablePair = getResult.left().value();
 507         AdditionalInfoParameterData parameterData = immutablePair.getLeft();
 508         Map<String, String> parameters = parameterData.getParameters();
 509         Integer counter = 0;
 510         if (parameters != null) {
 511             counter = parameters.size();
 512         }
 513         return Either.left(counter);
 514     }
 515
 516     public Either<AdditionalInfoParameterInfo, JanusGraphOperationStatus> getAdditionalInformationParameter(NodeTypeEnum nodeType, String componentId,
 517                                                                                                             String id) {
 518         JanusGraphOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId);
 519         if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) {
 520             return Either.right(verifyNodeTypeVsComponent);
 521         }
 522         Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 523             .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
 524                 NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
 525         if (getResult.isRight()) {
 526             JanusGraphOperationStatus status = getResult.right().value();
 527             return Either.right(status);
 528         }
 529         ImmutablePair<AdditionalInfoParameterData, GraphEdge> immutablePair = getResult.left().value();
 530         AdditionalInfoParameterData parameterData = immutablePair.getLeft();
 531         Map<String, String> parameters = parameterData.getParameters();
 532         Map<String, String> idToKey = parameterData.getIdToKey();
 533         if (idToKey == null || !idToKey.containsKey(id)) {
 534             return Either.right(JanusGraphOperationStatus.INVALID_ID);
 535         }
 536         String key = idToKey.get(id);
 537         String value = parameters.get(key);
 538         log.trace("The key-value {} = {} was retrieved for id {}", key, value, id);
 539         Either<AdditionalInfoParameterData, JanusGraphOperationStatus> updateNode = janusGraphGenericDao
 540             .updateNode(parameterData, AdditionalInfoParameterData.class);
 541         if (updateNode.isRight()) {
 542             JanusGraphOperationStatus status = updateNode.right().value();
 543             if (status != JanusGraphOperationStatus.NOT_FOUND) {
 544                 BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("GetAdditionnalInformationParameter",
 545                     ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status));
 546             }
 547             return Either.right(status);
 548         }
 549         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(id, key, value);
 550         return Either.left(additionalInfoParameterInfo);
 551     }
 552
 553     public Either<AdditionalInformationDefinition, JanusGraphOperationStatus> getAllAdditionalInformationParameters(NodeTypeEnum nodeType,
 554                                                                                                                     String componentId,
 555                                                                                                                     boolean ignoreVerification) {
 556         if (!ignoreVerification) {
 557             JanusGraphOperationStatus verifyNodeTypeVsComponent = verifyNodeTypeVsComponent(nodeType, componentId);
 558             if (verifyNodeTypeVsComponent != JanusGraphOperationStatus.OK) {
 559                 return Either.right(verifyNodeTypeVsComponent);
 560             }
 561         }
 562         Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 563             .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
 564                 NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
 565         if (getResult.isRight()) {
 566             JanusGraphOperationStatus status = getResult.right().value();
 567             if (status != JanusGraphOperationStatus.NOT_FOUND) {
 568                 BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("GetAdditionnalInformationParameters",
 569                     ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + componentId, String.valueOf(status));
 570             }
 571             return Either.right(status);
 572         }
 573         ImmutablePair<AdditionalInfoParameterData, GraphEdge> immutablePair = getResult.left().value();
 574         AdditionalInfoParameterData parameterData = immutablePair.getLeft();
 575         Map<String, String> parameters = parameterData.getParameters();
 576         Map<String, String> idToKey = parameterData.getIdToKey();
 577         AdditionalInformationDefinition informationDefinition = createInformationDefinitionFromNode(componentId, parameters, idToKey, parameterData);
 578         return Either.left(informationDefinition);
 579     }
 580
 581     public Either<AdditionalInformationDefinition, StorageOperationStatus> getAllAdditionalInformationParameters(NodeTypeEnum nodeType,
 582                                                                                                                  String resourceId,
 583                                                                                                                  boolean ignoreVerification,
 584                                                                                                                  boolean inTransaction) {
 585         Either<AdditionalInformationDefinition, StorageOperationStatus> result = null;
 586         try {
 587             Either<AdditionalInformationDefinition, JanusGraphOperationStatus> either = this
 588                 .getAllAdditionalInformationParameters(nodeType, resourceId, ignoreVerification);
 589             if (either.isRight()) {
 590                 JanusGraphOperationStatus status = either.right().value();
 591                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
 592             } else {
 593                 AdditionalInformationDefinition additionalInformationDefinition = either.left().value();
 594                 result = Either.left(additionalInformationDefinition);
 595             }
 596             return result;
 597         } finally {
 598             commitOrRollback(inTransaction, result);
 599         }
 600     }
 601
 602     private void commitOrRollback(boolean inTransaction, Either<? extends Object, StorageOperationStatus> result) {
 603         if (!inTransaction) {
 604             if (result == null || result.isRight()) {
 605                 log.error(GOING_TO_EXECUTE_ROLLBACK_ON_GRAPH);
 606                 janusGraphGenericDao.rollback();
 607             } else {
 608                 log.debug(GOING_TO_EXECUTE_COMMIT_ON_GRAPH);
 609                 janusGraphGenericDao.commit();
 610             }
 611         }
 612     }
 613
 614     public Either<AdditionalInfoParameterInfo, StorageOperationStatus> getAdditionalInformationParameter(NodeTypeEnum nodeType, String resourceId,
 615                                                                                                          String id, boolean inTransaction) {
 616         Either<AdditionalInfoParameterInfo, StorageOperationStatus> result = null;
 617         try {
 618             Either<AdditionalInfoParameterInfo, JanusGraphOperationStatus> either = this.getAdditionalInformationParameter(nodeType, resourceId, id);
 619             if (either.isRight()) {
 620                 log.error("Failed to fetch additional information property with id {} of component {}", id, resourceId);
 621                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(either.right().value()));
 622             } else {
 623                 AdditionalInfoParameterInfo additionalInformationDefinition = either.left().value();
 624                 result = Either.left(additionalInformationDefinition);
 625             }
 626             return result;
 627         } finally {
 628             commitOrRollback(inTransaction, result);
 629         }
 630     }
 631
 632     public Either<AdditionalInformationDefinition, StorageOperationStatus> deleteAllAdditionalInformationParameters(NodeTypeEnum nodeType,
 633                                                                                                                     String resourceId,
 634                                                                                                                     boolean inTransaction) {
 635         Either<AdditionalInformationDefinition, StorageOperationStatus> result = null;
 636         try {
 637             Either<ImmutablePair<AdditionalInfoParameterData, GraphEdge>, JanusGraphOperationStatus> getResult = janusGraphGenericDao
 638                 .getChild(UniqueIdBuilder.getKeyByNodeType(nodeType), resourceId, GraphEdgeLabels.ADDITIONAL_INFORMATION,
 639                     NodeTypeEnum.AdditionalInfoParameters, AdditionalInfoParameterData.class);
 640             if (getResult.isRight()) {
 641                 JanusGraphOperationStatus status = getResult.right().value();
 642                 if (status == JanusGraphOperationStatus.NOT_FOUND) {
 643                     return Either.right(StorageOperationStatus.OK);
 644                 } else {
 645                     BeEcompErrorManager.getInstance().logBeFailedDeleteNodeError("DeleteAdditionalInformationNode",
 646                         ADDITIONAL_INFORMATION_OF + nodeType.getName() + " " + resourceId, String.valueOf(status));
 647                     result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
 648                 }
 649                 return result;
 650             }
 651             ImmutablePair<AdditionalInfoParameterData, GraphEdge> value = getResult.left().value();
 652             AdditionalInfoParameterData parameterData = value.getLeft();
 653             Either<AdditionalInfoParameterData, JanusGraphOperationStatus> deleteNodeRes = janusGraphGenericDao
 654                 .deleteNode(parameterData, AdditionalInfoParameterData.class);
 655             if (deleteNodeRes.isRight()) {
 656                 JanusGraphOperationStatus status = getResult.right().value();
 657                 BeEcompErrorManager.getInstance()
 658                     .logBeFailedDeleteNodeError("DeleteAdditionalInformationNode", (String) parameterData.getUniqueId(), String.valueOf(status));
 659                 result = Either.right(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status));
 660                 return result;
 661             }
 662             AdditionalInformationDefinition informationDefinition = convertAdditionalInformationDataToDefinition(deleteNodeRes.left().value(),
 663                 resourceId);
 664             result = Either.left(informationDefinition);
 665             return result;
 666         } finally {
 667             commitOrRollback(inTransaction, result);
 668         }
 669     }
 670
 671     private JanusGraphOperationStatus verifyNodeTypeVsComponent(NodeTypeEnum nodeType, String componentId) {
 672         Either<JanusGraphVertex, JanusGraphOperationStatus> vertexByProperty = janusGraphGenericDao
 673             .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(nodeType), componentId);
 674         if (vertexByProperty.isRight()) {
 675             JanusGraphOperationStatus status = vertexByProperty.right().value();
 676             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 677                 status = JanusGraphOperationStatus.INVALID_ID;
 678             }
 679             return status;
 680         } else {
 681             Vertex v = vertexByProperty.left().value();
 682             String label = (String) v.property(GraphPropertiesDictionary.LABEL.getProperty()).value();
 683             if (label != null) {
 684                 if (!label.equals(nodeType.getName())) {
 685                     log.debug("The node type {} is not appropriate to component {}", nodeType, componentId);
 686                     return JanusGraphOperationStatus.INVALID_ID;
 687                 }
 688             } else {
 689                 log.debug("The node type {}  with id {} does not have a label property.", nodeType, componentId);
 690                 return JanusGraphOperationStatus.INVALID_ID;
 691             }
 692         }
 693         return JanusGraphOperationStatus.OK;
 694     }
 695 }