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