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     @Override
 244     public Either<List<GraphRelation>, StorageOperationStatus> dissociateAllGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String artifactId) {
 245
 246         List<GraphRelation> relations = new ArrayList<>();
 247         Either<List<GraphRelation>, StorageOperationStatus> result = Either.left(relations);
 248
 249         Either<List<GroupDefinition>, StorageOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
 250         if (allGroupsFromGraph.isRight()) {
 251             StorageOperationStatus status = allGroupsFromGraph.right().value();
 252             return Either.right(status);
 253         }
 254
 255         List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
 256         if (isEmpty(allGroups)) {
 257             return Either.right(StorageOperationStatus.OK);
 258         }
 259
 260         // Find all groups which contains this artifact id
 261         List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(artifactId)).collect(Collectors.toList());
 262
 263         if (isNotEmpty(associatedGroups)) {
 264             log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), artifactId);
 265
 266             UniqueIdData artifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId);
 267             for (GroupDefinition groupDefinition : associatedGroups) {
 268                 UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
 269                 Either<GraphRelation, StorageOperationStatus> deleteRelation = janusGraphGenericDao
 270                     .deleteRelation(groupData, artifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF)
 271                         .right()
 272                         .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 273                 if (deleteRelation.isRight()) {
 274                     StorageOperationStatus status = deleteRelation.right().value();
 275                     if (status == StorageOperationStatus.NOT_FOUND) {
 276                         status = StorageOperationStatus.INVALID_ID;
 277                     }
 278                     return Either.right(status);
 279                 }
 280
 281                 relations.add(deleteRelation.left().value());
 282             }
 283
 284             return result;
 285
 286         } else {
 287             log.debug("No group under component id {} is associated to artifact {}", componentId, artifactId);
 288             return Either.right(StorageOperationStatus.OK);
 289         }
 290
 291     }
 292
 293     public Either<GroupDefinition, StorageOperationStatus> getGroupFromGraph(String uniqueId, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
 294
 295         Either<GroupDefinition, StorageOperationStatus> result = null;
 296
 297         Either<GroupData, StorageOperationStatus> groupRes = janusGraphGenericDao
 298             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), uniqueId, GroupData.class)
 299                 .right()
 300                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 301         if (groupRes.isRight()) {
 302             StorageOperationStatus status = groupRes.right().value();
 303             log.debug("Failed to retrieve group {}  from graph. Status is {}", uniqueId, status);
 304             BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("Fetch Group", uniqueId, String.valueOf(status));
 305             result = Either.right(status);
 306             return result;
 307         }
 308
 309         GroupData groupData = groupRes.left().value();
 310
 311         GroupDefinition groupDefinition = convertGroupDataToGroupDefinition(groupData);
 312
 313         Either<GroupTypeDefinition, StorageOperationStatus> groupTypeOfGroup = getGroupTypeOfGroup(uniqueId);
 314
 315         if (groupTypeOfGroup.isRight()) {
 316             StorageOperationStatus status = groupTypeOfGroup.right().value();
 317             log.debug("Failed to retrieve capability type of capability {}. Status is {}", uniqueId, status);
 318
 319             result = Either.right(status);
 320             return result;
 321         }
 322
 323         GroupTypeDefinition groupTypeDefinition = groupTypeOfGroup.left().value();
 324
 325         groupDefinition.setTypeUid(groupTypeDefinition.getUniqueId());
 326
 327         if (!skipMembers) {
 328             Either<Map<String, String>, StorageOperationStatus> membersRes = getGroupMembers(uniqueId)
 329                     .right()
 330                     .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 331             if (membersRes.isRight()) {
 332                 StorageOperationStatus status = membersRes.right().value();
 333                 if (status != StorageOperationStatus.OK) {
 334                     result = Either.right(status);
 335                     return result;
 336                 }
 337             } else {
 338                 Map<String, String> members = membersRes.left().value();
 339                 groupDefinition.setMembers(members);
 340             }
 341         }
 342
 343         if (!skipProperties) {
 344             Either<List<GroupProperty>, StorageOperationStatus> propertiesRes = getGroupProperties(uniqueId);
 345             if (propertiesRes.isRight()) {
 346                 StorageOperationStatus status = propertiesRes.right().value();
 347                 if (status != StorageOperationStatus.OK) {
 348                     result = Either.right(status);
 349                     return result;
 350                 }
 351             } else {
 352                 List<GroupProperty> properties = propertiesRes.left().value();
 353                 groupDefinition.convertFromGroupProperties(properties);
 354             }
 355         }
 356
 357         if (!skipArtifacts) {
 358             Either<List<ImmutablePair<String, String>>, StorageOperationStatus> artifactsRes = getGroupArtifactsPairs(uniqueId)
 359                     .right()
 360                     .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 361             if (artifactsRes.isRight()) {
 362                 StorageOperationStatus status = artifactsRes.right().value();
 363                 if (status != StorageOperationStatus.OK) {
 364                     result = Either.right(status);
 365                     return result;
 366                 }
 367             } else {
 368                 List<String> artifactsUid = new ArrayList<>();
 369                 List<String> artifactsUUID = new ArrayList<>();
 370
 371                 List<ImmutablePair<String, String>> list = artifactsRes.left().value();
 372                 if (list != null) {
 373                     for (ImmutablePair<String, String> pair : list) {
 374                         String uid = pair.left;
 375                         String UUID = pair.right;
 376                         artifactsUid.add(uid);
 377                         artifactsUUID.add(UUID);
 378                     }
 379                     groupDefinition.setArtifacts(artifactsUid);
 380                     groupDefinition.setArtifactsUuid(artifactsUUID);
 381                 }
 382             }
 383         }
 384         result = Either.left(groupDefinition);
 385
 386         return result;
 387
 388     }
 389
 390     @Override
 391     public boolean isGroupExist(String groupName, boolean inTransaction) {
 392
 393         Either<List<GroupData>, JanusGraphOperationStatus> eitherGroup = null;
 394         try {
 395             Map<String, Object> properties = new HashMap<>();
 396             properties.put(GraphPropertiesDictionary.NAME.getProperty(), groupName);
 397
 398             eitherGroup = janusGraphGenericDao
 399                 .getByCriteria(NodeTypeEnum.Group, properties, GroupData.class);
 400             return eitherGroup.isLeft() && !eitherGroup.left().value().isEmpty();
 401
 402         } finally {
 403             handleTransactionCommitRollback(inTransaction, eitherGroup);
 404         }
 405     }
 406
 407     protected Either<List<GroupDefinition>, StorageOperationStatus> getAllGroupsFromGraph(String componentId, NodeTypeEnum componentTypeEnum, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
 408
 409         List<GroupDefinition> groups = new ArrayList<>();
 410
 411         Either<List<ImmutablePair<GroupData, GraphEdge>>, StorageOperationStatus> childrenNodes = janusGraphGenericDao
 412             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(componentTypeEnum), componentId, GraphEdgeLabels.GROUP, NodeTypeEnum.Group,
 413                 GroupData.class)
 414                 .right()
 415                 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 416
 417         if (childrenNodes.isRight()) {
 418             StorageOperationStatus status = childrenNodes.right().value();
 419             return Either.right(status);
 420         }
 421
 422         List<ImmutablePair<GroupData, GraphEdge>> graphGroups = childrenNodes.left().value();
 423
 424         if (isEmpty(graphGroups)) {
 425             return Either.right(StorageOperationStatus.NOT_FOUND);
 426         }
 427
 428
 429
 430                 for (ImmutablePair<GroupData, GraphEdge> pair : graphGroups) {
 431
 432             String groupUniqueId = pair.left.getGroupDataDefinition().getUniqueId();
 433             Either<GroupDefinition, StorageOperationStatus> groupRes = this.getGroupFromGraph(groupUniqueId, skipProperties, skipMembers, skipArtifacts);
 434
 435             if (groupRes.isRight()) {
 436                 StorageOperationStatus status = groupRes.right().value();
 437                 if (status == StorageOperationStatus.NOT_FOUND) {
 438                     status = StorageOperationStatus.INVALID_ID;
 439                 }
 440                 return Either.right(status);
 441             } else {
 442                 groups.add(groupRes.left().value());
 443             }
 444
 445         }
 446
 447         return Either.left(groups);
 448     }
 449
 450     private StorageOperationStatus dissociateAndAssociateGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact) {
 451
 452                 Either<List<GroupDefinition>, StorageOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
 453                 if (allGroupsFromGraph.isRight()) {
 454                         return allGroupsFromGraph.right().value();
 455
 456                 }
 457
 458         List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
 459         if (isEmpty(allGroups)) {
 460             return StorageOperationStatus.OK;
 461         }
 462
 463         // Find all groups which contains this artifact id
 464         List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(oldArtifactId)).collect(Collectors.toList());
 465
 466         if (isNotEmpty(associatedGroups)) {
 467
 468             log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), oldArtifactId);
 469
 470             UniqueIdData oldArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, oldArtifactId);
 471             UniqueIdData newArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, newArtifact.getArtifactDataDefinition().getUniqueId());
 472             Map<String, Object> props = new HashMap<>();
 473             props.put(GraphPropertiesDictionary.NAME.getProperty(), newArtifactData.getLabel());
 474
 475             for (GroupDefinition groupDefinition : associatedGroups) {
 476                 UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
 477
 478                 Either<GraphRelation, StorageOperationStatus> deleteRelation = janusGraphGenericDao
 479                     .deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF)
 480                         .right()
 481                         .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 482                 log.trace("After dissociate group {} from artifact {}"  , groupDefinition.getName(), oldArtifactId);
 483                 if (deleteRelation.isRight()) {
 484                     StorageOperationStatus status = deleteRelation.right().value();
 485                     if (status == StorageOperationStatus.NOT_FOUND) {
 486                         status = StorageOperationStatus.INVALID_ID;
 487                     }
 488                     return status;
 489                 }
 490
 491                 Either<GraphRelation, StorageOperationStatus> createRelation = janusGraphGenericDao
 492                     .createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props)
 493                         .right()
 494                         .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 495                 log.trace("After associate group {} to artifact {}" , groupDefinition.getName(), newArtifact.getUniqueIdKey());
 496                 if (createRelation.isRight()) {
 497                     StorageOperationStatus status = createRelation.right().value();
 498                     if (status == StorageOperationStatus.NOT_FOUND) {
 499                         status = StorageOperationStatus.INVALID_ID;
 500                     }
 501                     return status;
 502                 }
 503             }
 504
 505         }
 506         return StorageOperationStatus.OK;
 507     }
 508
 509     @Override
 510     public StorageOperationStatus dissociateAndAssociateGroupsFromArtifact(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact, boolean inTransaction) {
 511
 512         StorageOperationStatus result = null;
 513
 514         try {
 515             StorageOperationStatus status = this.dissociateAndAssociateGroupsFromArtifactOnGraph(componentId, componentTypeEnum, oldArtifactId, newArtifact);
 516
 517             if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
 518                 return status;
 519             }
 520
 521             result = StorageOperationStatus.OK;
 522             return result;
 523
 524         } finally {
 525             if (!inTransaction) {
 526                 if (result == null || result != StorageOperationStatus.OK) {
 527                     log.debug("Going to execute rollback on graph.");
 528                     BeEcompErrorManager.getInstance().logBeExecuteRollbackError("Rollback on graph");
 529                     janusGraphGenericDao.rollback();
 530                 } else {
 531                     log.debug("Going to execute commit on graph.");
 532                     janusGraphGenericDao.commit();
 533                 }
 534             }
 535         }
 536     }
 537
 538     private Either<List<ImmutablePair<String, String>>, JanusGraphOperationStatus> getGroupArtifactsPairs(String groupUniqueId) {
 539
 540         Either<List<ImmutablePair<String, String>>, JanusGraphOperationStatus> result = null;
 541
 542         Either<List<ImmutablePair<ArtifactData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
 543             .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF,
 544                 NodeTypeEnum.ArtifactRef, ArtifactData.class);
 545         if (childrenNodes.isRight()) {
 546             JanusGraphOperationStatus status = childrenNodes.right().value();
 547             if (status == JanusGraphOperationStatus.NOT_FOUND) {
 548                 status = JanusGraphOperationStatus.OK;
 549             }
 550             result = Either.right(status);
 551
 552         } else {
 553
 554             List<ImmutablePair<String, String>> artifactsList = new ArrayList<>();
 555             List<ImmutablePair<ArtifactData, GraphEdge>> list = childrenNodes.left().value();
 556             if (list != null) {
 557                 for (ImmutablePair<ArtifactData, GraphEdge> pair : list) {
 558                     ArtifactData artifactData = pair.getKey();
 559                     String uniqueId = artifactData.getArtifactDataDefinition().getUniqueId();
 560                     String UUID = artifactData.getArtifactDataDefinition().getArtifactUUID();
 561                     ImmutablePair<String, String> artifact = new ImmutablePair<>(uniqueId, UUID);
 562                     artifactsList.add(artifact);
 563                 }
 564             }
 565
 566             log.debug("The artifacts list related to group {} is {}", groupUniqueId, artifactsList);
 567             result = Either.left(artifactsList);
 568         }
 569
 570         return result;
 571
 572     }
 573
 574     @Override
 575     public StorageOperationStatus validateAndUpdatePropertyValue(GroupProperty property) {
 576
 577         StorageOperationStatus result = null;
 578         String innerType = property.getSchema() == null ? null : property.getSchema().getProperty() == null ? null : property.getSchema().getProperty().getType();
 579         Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
 580         Either<Object, Boolean> isValid = null;
 581         if (allDataTypes.isRight()) {
 582             JanusGraphOperationStatus status = allDataTypes.right().value();
 583             log.debug("Failed to fetch data types from cache. Status is {}. ", status);
 584             result = DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status);
 585         }
 586         if(result == null){
 587             isValid = propertyOperation.validateAndUpdatePropertyValue(property.getType(), property.getValue(), innerType, allDataTypes.left().value());
 588             if(isValid.isRight()){
 589                 log.debug("Failed to validate property value {}. Status is {}. ", property.getValue(), StorageOperationStatus.INVALID_PROPERTY);
 590                 result =  StorageOperationStatus.INVALID_PROPERTY;
 591             }
 592         }
 593         if(result == null){
 594             String validValue = String.valueOf(isValid.left().value());
 595             property.setValue(validValue);
 596             result = StorageOperationStatus.OK;
 597         }
 598         return result;
 599     }
 600
 601         public StorageOperationStatus updateGroupProperties(org.openecomp.sdc.be.model.Component containerComponent, String groupId, List<PropertyDataDefinition> propertiesToUpdate) {
 602                 log.debug("#updateGroupProperties - updating the properties of group {} in component {}", groupId, containerComponent.getUniqueId());
 603                 Optional<GroupDefinition> group = containerComponent.getGroupById(groupId);
 604                 if (group.isPresent()){
 605                         return janusGraphDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.NoParse)
 606                                         .either(containerVertex -> updateGroupProperties(containerVertex, group.get(), propertiesToUpdate),
 607                                                         DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
 608                 } else {
 609                         throw new StorageException(StorageOperationStatus.NOT_FOUND, groupId);
 610                 }
 611         }
 612
 613         private StorageOperationStatus updateGroupProperties(GraphVertex container, GroupDefinition group, List<PropertyDataDefinition> propertiesToUpdate) {
 614                 List<PropertyDataDefinition> groupProperties = group.getProperties();
 615                 List<PropertyDataDefinition> updatedGroupProperties = updateGroupProperties(groupProperties, propertiesToUpdate);
 616                 group.setProperties(updatedGroupProperties);
 617                 return topologyTemplateOperation.updateGroupOfToscaElement(container, group);
 618         }
 619
 620         private List<PropertyDataDefinition> updateGroupProperties(List<PropertyDataDefinition> currentGroupProperties, List<PropertyDataDefinition> toBeUpdatedProperties) {
 621                 Map<String, PropertyDataDefinition> currPropsByName = MapUtil.toMap(currentGroupProperties, PropertyDataDefinition::getName);
 622                 overrideCurrentPropertiesWithUpdatedProperties(currPropsByName, toBeUpdatedProperties);
 623                 return new ArrayList<>(currPropsByName.values());
 624         }
 625
 626         private void overrideCurrentPropertiesWithUpdatedProperties(Map<String, PropertyDataDefinition> currPropsByName, List<PropertyDataDefinition> toBeUpdatedProperties) {
 627                 toBeUpdatedProperties.forEach(prop -> currPropsByName.put(prop.getName(), prop));
 628         }
 629
 630 }