catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/GroupOperation.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.operations.impl;
  22
  23 import fj.data.Either;
  24 import org.apache.commons.lang3.tuple.ImmutablePair;
  25 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  26 import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
  27 import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
  28 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  29 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  30 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  31 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  32 import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
  33 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  34 import org.openecomp.sdc.be.dao.utils.MapUtil;
  35 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  36 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  37 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  38 import org.openecomp.sdc.be.model.*;
  39 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  40 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation;
  41 import org.openecomp.sdc.be.model.operations.StorageException;
  42 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  43 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  44 import org.openecomp.sdc.be.resources.data.*;
  45 import org.openecomp.sdc.common.log.wrappers.Logger;
  46 import org.springframework.stereotype.Component;
  47
  48 import java.util.*;
  49 import java.util.function.Function;
  50 import java.util.stream.Collectors;
  51
  52 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
  53 import static org.springframework.util.CollectionUtils.isEmpty;
  54
  55
  56 @Component
  57 public class GroupOperation extends AbstractOperation implements IGroupOperation {
  58
  59
  60     private static final Logger log = Logger.getLogger(GroupOperation.class.getName());
  61         private final JanusGraphDao janusGraphDao;
  62         private final TopologyTemplateOperation topologyTemplateOperation;
  63     private final PropertyOperation propertyOperation;
  64     private final GroupTypeOperation groupTypeOperation;
  65     private final ApplicationDataTypeCache dataTypeCache;
  66
  67     public GroupOperation(JanusGraphDao janusGraphDao, TopologyTemplateOperation topologyTemplateOperation, PropertyOperation propertyOperation, GroupTypeOperation groupTypeOperation, ApplicationDataTypeCache dataTypeCache) {
  68         this.janusGraphDao = janusGraphDao;
  69         this.topologyTemplateOperation = topologyTemplateOperation;
  70         this.propertyOperation = propertyOperation;
  71         this.groupTypeOperation = groupTypeOperation;
  72         this.dataTypeCache = dataTypeCache;
  73     }
  74
  75     private GroupDefinition convertGroupDataToGroupDefinition(GroupData groupData) {
  76                 return new GroupDefinition(groupData.getGroupDataDefinition());
  77
  78         }
  79
  80     /**
  81      * get members of group
  82      *
  83      * @param groupUniqueId
  84      * @return
  85      */
  86     private Either<Map<String, String>, JanusGraphOperationStatus> getGroupMembers(String groupUniqueId) {
  87
  88         Either<Map<String, String>, JanusGraphOperationStatus> result = null;
  89
  90         Either<List<ImmutablePair<ComponentInstanceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
  91             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_MEMBER,
  92                 NodeTypeEnum.ResourceInstance, ComponentInstanceData.class);
  93
  94         if (childrenNodes.isRight()) {
  95             JanusGraphOperationStatus status = childrenNodes.right().value();
  96             if (status == JanusGraphOperationStatus.NOT_FOUND) {
  97                 status = JanusGraphOperationStatus.OK;
  98             }
  99             result = Either.right(status);
 100
 101         } else {
 102
 103             Map<String, String> compInstaMap = new HashMap<>();
 104             List<ImmutablePair<ComponentInstanceData, GraphEdge>> list = childrenNodes.left().value();
 105             if (list != null) {
 106                 for (ImmutablePair<ComponentInstanceData, GraphEdge> pair : list) {
 107                     ComponentInstanceData componentInstanceData = pair.getKey();
 108
 109                     String compInstUniqueId = componentInstanceData.getComponentInstDataDefinition().getUniqueId();
 110                     String compInstName = componentInstanceData.getName();
 111                     compInstaMap.put(compInstName, compInstUniqueId);
 112                 }
 113             }
 114
 115             result = Either.left(compInstaMap);
 116         }
 117
 118         return result;
 119     }
 120
 121     private Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeOfGroup(String groupUniqueId) {
 122
 123         Either<ImmutablePair<GroupTypeData, GraphEdge>, StorageOperationStatus> groupTypeRes = janusGraphGenericDao
 124             .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.TYPE_OF, NodeTypeEnum.GroupType,
 125                 GroupTypeData.class)
 126                 .right()
 127                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 128
 129         if (groupTypeRes.isRight()) {
 130             StorageOperationStatus status = groupTypeRes.right().value();
 131             log.debug("Cannot find group type associated with capability {}. Status is {}", groupUniqueId, status);
 132
 133             BeEcompErrorManager.getInstance().logBeFailedFindAssociationError("Fetch Group type", NodeTypeEnum.GroupType.getName(), groupUniqueId, String.valueOf(status));
 134             return Either.right(groupTypeRes.right().value());
 135         }
 136
 137         GroupTypeData groupTypeData = groupTypeRes.left().value().getKey();
 138
 139         return groupTypeOperation.getGroupTypeByUid(groupTypeData.getGroupTypeDataDefinition().getUniqueId());
 140
 141     }
 142
 143     /**
 144      * get all properties of the group.
 145      *
 146      * the propert definition is taken from the group type.
 147      *
 148      * @param groupUid
 149      * @return
 150      */
 151     private Either<List<GroupProperty>, StorageOperationStatus> getGroupProperties(String groupUid) {
 152
 153         List<GroupProperty> groupPropertiesList = new ArrayList<>();
 154
 155         Either<GroupTypeDefinition, StorageOperationStatus> groupTypeOfGroupRes = getGroupTypeOfGroup(groupUid);
 156
 157         if (groupTypeOfGroupRes.isRight()) {
 158             StorageOperationStatus status = groupTypeOfGroupRes.right().value();
 159             return Either.right(status);
 160         }
 161
 162         GroupTypeDefinition groupTypeDefinition = groupTypeOfGroupRes.left().value();
 163
 164         // Get the properties on the group type of this group
 165         List<PropertyDefinition> groupTypeProperties = groupTypeDefinition.getProperties();
 166
 167         if (isEmpty(groupTypeProperties)) {
 168             return Either.right(StorageOperationStatus.OK);
 169         }
 170
 171         Map<String, PropertyDefinition> uidToPropDefMap = groupTypeProperties.stream().collect(Collectors.toMap(PropertyDefinition::getUniqueId, Function.identity()));
 172
 173         // Find all properties values on the group
 174         Either<List<ImmutablePair<PropertyValueData, GraphEdge>>, StorageOperationStatus> propertyImplNodes = janusGraphGenericDao
 175             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUid, GraphEdgeLabels.PROPERTY_VALUE,
 176                 NodeTypeEnum.PropertyValue, PropertyValueData.class)
 177                 .right()
 178                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 179
 180         if (propertyImplNodes.isRight()) {
 181             StorageOperationStatus status = propertyImplNodes.right().value();
 182             if (status == StorageOperationStatus.NOT_FOUND) {
 183                 groupPropertiesList = groupTypeProperties.stream().map(p -> new GroupProperty(p, p.getDefaultValue(), null)).collect(Collectors.toList());
 184                 return Either.left(groupPropertiesList);
 185             } else {
 186                 return Either.right(status);
 187             }
 188         }
 189
 190         List<ImmutablePair<PropertyValueData, GraphEdge>> list = propertyImplNodes.left().value();
 191         if (isEmpty(list)) {
 192             return Either.right(StorageOperationStatus.OK);
 193         }
 194
 195         List<String> processedProps = new ArrayList<>();
 196
 197         for (ImmutablePair<PropertyValueData, GraphEdge> propertyValue : list) {
 198
 199             PropertyValueData propertyValueData = propertyValue.getLeft();
 200             String propertyValueUid = propertyValueData.getUniqueId();
 201             String value = propertyValueData.getValue();
 202
 203             Either<ImmutablePair<PropertyData, GraphEdge>, StorageOperationStatus> propertyDefRes = janusGraphGenericDao
 204                 .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, GraphEdgeLabels.PROPERTY_IMPL,
 205                     NodeTypeEnum.Property, PropertyData.class)
 206                     .right()
 207                     .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 208             if (propertyDefRes.isRight()) {
 209                 StorageOperationStatus status = propertyDefRes.right().value();
 210                 if (status == StorageOperationStatus.NOT_FOUND) {
 211                     status = StorageOperationStatus.INVALID_ID;
 212                 }
 213                 return Either.right(status);
 214             }
 215
 216             ImmutablePair<PropertyData, GraphEdge> propertyDefPair = propertyDefRes.left().value();
 217
 218             PropertyData propertyData = propertyDefPair.left;
 219             String propertyUniqueId = propertyData.getPropertyDataDefinition().getUniqueId();
 220
 221             PropertyDefinition propertyDefinition = uidToPropDefMap.get(propertyUniqueId);
 222             GroupProperty groupProperty = new GroupProperty(propertyDefinition, value, propertyValueUid);
 223
 224             processedProps.add(propertyUniqueId);
 225
 226             groupPropertiesList.add(groupProperty);
 227
 228         }
 229
 230         // Find all properties which does not have property value on the group.
 231         List<GroupProperty> leftProps = groupTypeProperties.stream()
 232                 // filter out the group type properties which already processed
 233                 .filter(p -> !processedProps.contains(p.getUniqueId()))
 234                 .map(p -> new GroupProperty(p, p.getDefaultValue(), null))
 235                 .collect(Collectors.toList());
 236         if (leftProps != null) {
 237             groupPropertiesList.addAll(leftProps);
 238         }
 239
 240         return Either.left(groupPropertiesList);
 241     }
 242
 243     public Either<List<GraphRelation>, StorageOperationStatus> dissociateAllGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String artifactId) {
 244
 245         List<GraphRelation> relations = new ArrayList<>();
 246         Either<List<GraphRelation>, StorageOperationStatus> result = Either.left(relations);
 247
 248         Either<List<GroupDefinition>, StorageOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
 249         if (allGroupsFromGraph.isRight()) {
 250             StorageOperationStatus status = allGroupsFromGraph.right().value();
 251             return Either.right(status);
 252         }
 253
 254         List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
 255         if (isEmpty(allGroups)) {
 256             return Either.right(StorageOperationStatus.OK);
 257         }
 258
 259         // Find all groups which contains this artifact id
 260         List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(artifactId)).collect(Collectors.toList());
 261
 262         if (isNotEmpty(associatedGroups)) {
 263             log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), artifactId);
 264
 265             UniqueIdData artifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId);
 266             for (GroupDefinition groupDefinition : associatedGroups) {
 267                 UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
 268                 Either<GraphRelation, StorageOperationStatus> deleteRelation = janusGraphGenericDao
 269                     .deleteRelation(groupData, artifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF)
 270                         .right()
 271                         .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 272                 if (deleteRelation.isRight()) {
 273                     StorageOperationStatus status = deleteRelation.right().value();
 274                     if (status == StorageOperationStatus.NOT_FOUND) {
 275                         status = StorageOperationStatus.INVALID_ID;
 276                     }
 277                     return Either.right(status);
 278                 }
 279
 280                 relations.add(deleteRelation.left().value());
 281             }
 282
 283             return result;
 284
 285         } else {
 286             log.debug("No group under component id {} is associated to artifact {}", componentId, artifactId);
 287             return Either.right(StorageOperationStatus.OK);
 288         }
 289
 290     }
 291
 292     public Either<GroupDefinition, StorageOperationStatus> getGroupFromGraph(String uniqueId, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
 293
 294         Either<GroupDefinition, StorageOperationStatus> result = null;
 295
 296         Either<GroupData, StorageOperationStatus> groupRes = janusGraphGenericDao
 297             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), uniqueId, GroupData.class)
 298                 .right()
 299                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 300         if (groupRes.isRight()) {
 301             StorageOperationStatus status = groupRes.right().value();
 302             log.debug("Failed to retrieve group {}  from graph. Status is {}", uniqueId, status);
 303             BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("Fetch Group", uniqueId, String.valueOf(status));
 304             result = Either.right(status);
 305             return result;
 306         }
 307
 308         GroupData groupData = groupRes.left().value();
 309
 310         GroupDefinition groupDefinition = convertGroupDataToGroupDefinition(groupData);
 311
 312         Either<GroupTypeDefinition, StorageOperationStatus> groupTypeOfGroup = getGroupTypeOfGroup(uniqueId);
 313
 314         if (groupTypeOfGroup.isRight()) {
 315             StorageOperationStatus status = groupTypeOfGroup.right().value();
 316             log.debug("Failed to retrieve capability type of capability {}. Status is {}", uniqueId, status);
 317
 318             result = Either.right(status);
 319             return result;
 320         }
 321
 322         GroupTypeDefinition groupTypeDefinition = groupTypeOfGroup.left().value();
 323
 324         groupDefinition.setTypeUid(groupTypeDefinition.getUniqueId());
 325
 326         if (!skipMembers) {
 327             Either<Map<String, String>, StorageOperationStatus> membersRes = getGroupMembers(uniqueId)
 328                     .right()
 329                     .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 330             if (membersRes.isRight()) {
 331                 StorageOperationStatus status = membersRes.right().value();
 332                 if (status != StorageOperationStatus.OK) {
 333                     result = Either.right(status);
 334                     return result;
 335                 }
 336             } else {
 337                 Map<String, String> members = membersRes.left().value();
 338                 groupDefinition.setMembers(members);
 339             }
 340         }
 341
 342         if (!skipProperties) {
 343             Either<List<GroupProperty>, StorageOperationStatus> propertiesRes = getGroupProperties(uniqueId);
 344             if (propertiesRes.isRight()) {
 345                 StorageOperationStatus status = propertiesRes.right().value();
 346                 if (status != StorageOperationStatus.OK) {
 347                     result = Either.right(status);
 348                     return result;
 349                 }
 350             } else {
 351                 List<GroupProperty> properties = propertiesRes.left().value();
 352                 groupDefinition.convertFromGroupProperties(properties);
 353             }
 354         }
 355
 356         if (!skipArtifacts) {
 357             Either<List<ImmutablePair<String, String>>, StorageOperationStatus> artifactsRes = getGroupArtifactsPairs(uniqueId)
 358                     .right()
 359                     .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 360             if (artifactsRes.isRight()) {
 361                 StorageOperationStatus status = artifactsRes.right().value();
 362                 if (status != StorageOperationStatus.OK) {
 363                     result = Either.right(status);
 364                     return result;
 365                 }
 366             } else {
 367                 List<String> artifactsUid = new ArrayList<>();
 368                 List<String> artifactsUUID = new ArrayList<>();
 369
 370                 List<ImmutablePair<String, String>> list = artifactsRes.left().value();
 371                 if (list != null) {
 372                     for (ImmutablePair<String, String> pair : list) {
 373                         String uid = pair.left;
 374                         String UUID = pair.right;
 375                         artifactsUid.add(uid);
 376                         artifactsUUID.add(UUID);
 377                     }
 378                     groupDefinition.setArtifacts(artifactsUid);
 379                     groupDefinition.setArtifactsUuid(artifactsUUID);
 380                 }
 381             }
 382         }
 383         result = Either.left(groupDefinition);
 384
 385         return result;
 386
 387     }
 388
 389     public boolean isGroupExist(String groupName, boolean inTransaction) {
 390
 391         Either<List<GroupData>, JanusGraphOperationStatus> eitherGroup = null;
 392         try {
 393             Map<String, Object> properties = new HashMap<>();
 394             properties.put(GraphPropertiesDictionary.NAME.getProperty(), groupName);
 395
 396             eitherGroup = janusGraphGenericDao
 397                 .getByCriteria(NodeTypeEnum.Group, properties, GroupData.class);
 398             return eitherGroup.isLeft() && !eitherGroup.left().value().isEmpty();
 399
 400         } finally {
 401             handleTransactionCommitRollback(inTransaction, eitherGroup);
 402         }
 403     }
 404
 405     protected Either<List<GroupDefinition>, StorageOperationStatus> getAllGroupsFromGraph(String componentId, NodeTypeEnum componentTypeEnum, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
 406
 407         List<GroupDefinition> groups = new ArrayList<>();
 408
 409         Either<List<ImmutablePair<GroupData, GraphEdge>>, StorageOperationStatus> childrenNodes = janusGraphGenericDao
 410             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(componentTypeEnum), componentId, GraphEdgeLabels.GROUP, NodeTypeEnum.Group,
 411                 GroupData.class)
 412                 .right()
 413                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 414
 415         if (childrenNodes.isRight()) {
 416             StorageOperationStatus status = childrenNodes.right().value();
 417             return Either.right(status);
 418         }
 419
 420         List<ImmutablePair<GroupData, GraphEdge>> graphGroups = childrenNodes.left().value();
 421
 422         if (isEmpty(graphGroups)) {
 423             return Either.right(StorageOperationStatus.NOT_FOUND);
 424         }
 425
 426
 427
 428                 for (ImmutablePair<GroupData, GraphEdge> pair : graphGroups) {
 429
 430             String groupUniqueId = pair.left.getGroupDataDefinition().getUniqueId();
 431             Either<GroupDefinition, StorageOperationStatus> groupRes = this.getGroupFromGraph(groupUniqueId, skipProperties, skipMembers, skipArtifacts);
 432
 433             if (groupRes.isRight()) {
 434                 StorageOperationStatus status = groupRes.right().value();
 435                 if (status == StorageOperationStatus.NOT_FOUND) {
 436                     status = StorageOperationStatus.INVALID_ID;
 437                 }
 438                 return Either.right(status);
 439             } else {
 440                 groups.add(groupRes.left().value());
 441             }
 442
 443         }
 444
 445         return Either.left(groups);
 446     }
 447
 448     private StorageOperationStatus dissociateAndAssociateGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact) {
 449
 450                 Either<List<GroupDefinition>, StorageOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
 451                 if (allGroupsFromGraph.isRight()) {
 452                         return allGroupsFromGraph.right().value();
 453
 454                 }
 455
 456         List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
 457         if (isEmpty(allGroups)) {
 458             return StorageOperationStatus.OK;
 459         }
 460
 461         // Find all groups which contains this artifact id
 462         List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(oldArtifactId)).collect(Collectors.toList());
 463
 464         if (isNotEmpty(associatedGroups)) {
 465
 466             log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), oldArtifactId);
 467
 468             UniqueIdData oldArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, oldArtifactId);
 469             UniqueIdData newArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, newArtifact.getArtifactDataDefinition().getUniqueId());
 470             Map<String, Object> props = new HashMap<>();
 471             props.put(GraphPropertiesDictionary.NAME.getProperty(), newArtifactData.getLabel());
 472
 473             for (GroupDefinition groupDefinition : associatedGroups) {
 474                 UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
 475
 476                 Either<GraphRelation, StorageOperationStatus> deleteRelation = janusGraphGenericDao
 477                     .deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF)
 478                         .right()
 479                         .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 480                 log.trace("After dissociate group {} from artifact {}"  , groupDefinition.getName(), oldArtifactId);
 481                 if (deleteRelation.isRight()) {
 482                     StorageOperationStatus status = deleteRelation.right().value();
 483                     if (status == StorageOperationStatus.NOT_FOUND) {
 484                         status = StorageOperationStatus.INVALID_ID;
 485                     }
 486                     return status;
 487                 }
 488
 489                 Either<GraphRelation, StorageOperationStatus> createRelation = janusGraphGenericDao
 490                     .createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props)
 491                         .right()
 492                         .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 493                 log.trace("After associate group {} to artifact {}" , groupDefinition.getName(), newArtifact.getUniqueIdKey());
 494                 if (createRelation.isRight()) {
 495                     StorageOperationStatus status = createRelation.right().value();
 496                     if (status == StorageOperationStatus.NOT_FOUND) {
 497                         status = StorageOperationStatus.INVALID_ID;
 498                     }
 499                     return status;
 500                 }
 501             }
 502
 503         }
 504         return StorageOperationStatus.OK;
 505     }
 506
 507     public StorageOperationStatus dissociateAndAssociateGroupsFromArtifact(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact, boolean inTransaction) {
 508
 509         StorageOperationStatus result = null;
 510
 511         try {
 512             StorageOperationStatus status = this.dissociateAndAssociateGroupsFromArtifactOnGraph(componentId, componentTypeEnum, oldArtifactId, newArtifact);
 513
 514             if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
 515                 return status;
 516             }
 517
 518             result = StorageOperationStatus.OK;
 519             return result;
 520
 521         } finally {
 522             if (!inTransaction) {
 523                 if (result == null || result != StorageOperationStatus.OK) {
 524                     log.debug("Going to execute rollback on graph.");
 525                     BeEcompErrorManager.getInstance().logBeExecuteRollbackError("Rollback on graph");
 526                     janusGraphGenericDao.rollback();
 527                 } else {
 528                     log.debug("Going to execute commit on graph.");
 529                     janusGraphGenericDao.commit();
 530                 }
 531             }
 532         }
 533     }
 534
 535     private Either<List<ImmutablePair<String, String>>, JanusGraphOperationStatus> getGroupArtifactsPairs(String groupUniqueId) {
 536
 537         Either<List<ImmutablePair<String, String>>, JanusGraphOperationStatus> result = null;
 538
 539         Either<List<ImmutablePair<ArtifactData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 540             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF,
 541                 NodeTypeEnum.ArtifactRef, ArtifactData.class);
 542         if (childrenNodes.isRight()) {
 543             JanusGraphOperationStatus status = childrenNodes.right().value();
 544             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 545                 status = JanusGraphOperationStatus.OK;
 546             }
 547             result = Either.right(status);
 548
 549         } else {
 550
 551             List<ImmutablePair<String, String>> artifactsList = new ArrayList<>();
 552             List<ImmutablePair<ArtifactData, GraphEdge>> list = childrenNodes.left().value();
 553             if (list != null) {
 554                 for (ImmutablePair<ArtifactData, GraphEdge> pair : list) {
 555                     ArtifactData artifactData = pair.getKey();
 556                     String uniqueId = artifactData.getArtifactDataDefinition().getUniqueId();
 557                     String UUID = artifactData.getArtifactDataDefinition().getArtifactUUID();
 558                     ImmutablePair<String, String> artifact = new ImmutablePair<>(uniqueId, UUID);
 559                     artifactsList.add(artifact);
 560                 }
 561             }
 562
 563             log.debug("The artifacts list related to group {} is {}", groupUniqueId, artifactsList);
 564             result = Either.left(artifactsList);
 565         }
 566
 567         return result;
 568
 569     }
 570
 571     public StorageOperationStatus validateAndUpdatePropertyValue(GroupProperty property) {
 572
 573         StorageOperationStatus result = null;
 574         String innerType = property.getSchema() == null ? null : property.getSchema().getProperty() == null ? null : property.getSchema().getProperty().getType();
 575         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
 576         Either<Object, Boolean> isValid = null;
 577         if (allDataTypes.isRight()) {
 578             JanusGraphOperationStatus status = allDataTypes.right().value();
 579             log.debug("Failed to fetch data types from cache. Status is {}. ", status);
 580             result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
 581         }
 582         if(result == null){
 583             isValid = propertyOperation.validateAndUpdatePropertyValue(property.getType(), property.getValue(), innerType, allDataTypes.left().value());
 584             if(isValid.isRight()){
 585                 log.debug("Failed to validate property value {}. Status is {}. ", property.getValue(), StorageOperationStatus.INVALID_PROPERTY);
 586                 result =  StorageOperationStatus.INVALID_PROPERTY;
 587             }
 588         }
 589         if(result == null){
 590             String validValue = String.valueOf(isValid.left().value());
 591             property.setValue(validValue);
 592             result = StorageOperationStatus.OK;
 593         }
 594         return result;
 595     }
 596
 597         public StorageOperationStatus updateGroupProperties(org.openecomp.sdc.be.model.Component containerComponent, String groupId, List<PropertyDataDefinition> propertiesToUpdate) {
 598                 log.debug("#updateGroupProperties - updating the properties of group {} in component {}", groupId, containerComponent.getUniqueId());
 599                 Optional<GroupDefinition> group = containerComponent.getGroupById(groupId);
 600                 if (group.isPresent()){
 601                         return janusGraphDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.NoParse)
 602                                         .either(containerVertex -> updateGroupProperties(containerVertex, group.get(), propertiesToUpdate),
 603                                                         DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 604                 } else {
 605                         throw new StorageException(StorageOperationStatus.NOT_FOUND, groupId);
 606                 }
 607         }
 608
 609         private StorageOperationStatus updateGroupProperties(GraphVertex container, GroupDefinition group, List<PropertyDataDefinition> propertiesToUpdate) {
 610                 List<PropertyDataDefinition> groupProperties = group.getProperties();
 611                 List<PropertyDataDefinition> updatedGroupProperties = updateGroupProperties(groupProperties, propertiesToUpdate);
 612                 group.setProperties(updatedGroupProperties);
 613                 return topologyTemplateOperation.updateGroupOfToscaElement(container, group);
 614         }
 615
 616         private List<PropertyDataDefinition> updateGroupProperties(List<PropertyDataDefinition> currentGroupProperties, List<PropertyDataDefinition> toBeUpdatedProperties) {
 617                 Map<String, PropertyDataDefinition> currPropsByName = MapUtil.toMap(currentGroupProperties, PropertyDataDefinition::getName);
 618                 overrideCurrentPropertiesWithUpdatedProperties(currPropsByName, toBeUpdatedProperties);
 619                 return new ArrayList<>(currPropsByName.values());
 620         }
 621
 622         private void overrideCurrentPropertiesWithUpdatedProperties(Map<String, PropertyDataDefinition> currPropsByName, List<PropertyDataDefinition> toBeUpdatedProperties) {
 623                 toBeUpdatedProperties.forEach(prop -> currPropsByName.put(prop.getName(), prop));
 624         }
 625
 626 }