2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.be.model.operations.impl;
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;
49 import java.util.function.Function;
50 import java.util.stream.Collectors;
52 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
53 import static org.springframework.util.CollectionUtils.isEmpty;
57 public class GroupOperation extends AbstractOperation implements IGroupOperation {
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;
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;
75 private GroupDefinition convertGroupDataToGroupDefinition(GroupData groupData) {
76 return new GroupDefinition(groupData.getGroupDataDefinition());
81 * get members of group
83 * @param groupUniqueId
86 private Either<Map<String, String>, JanusGraphOperationStatus> getGroupMembers(String groupUniqueId) {
88 Either<Map<String, String>, JanusGraphOperationStatus> result = null;
90 Either<List<ImmutablePair<ComponentInstanceData, GraphEdge>>, JanusGraphOperationStatus> childrenNodes = janusGraphGenericDao
91 .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_MEMBER,
92 NodeTypeEnum.ResourceInstance, ComponentInstanceData.class);
94 if (childrenNodes.isRight()) {
95 JanusGraphOperationStatus status = childrenNodes.right().value();
96 if (status == JanusGraphOperationStatus.NOT_FOUND) {
97 status = JanusGraphOperationStatus.OK;
99 result = Either.right(status);
103 Map<String, String> compInstaMap = new HashMap<>();
104 List<ImmutablePair<ComponentInstanceData, GraphEdge>> list = childrenNodes.left().value();
106 for (ImmutablePair<ComponentInstanceData, GraphEdge> pair : list) {
107 ComponentInstanceData componentInstanceData = pair.getKey();
109 String compInstUniqueId = componentInstanceData.getComponentInstDataDefinition().getUniqueId();
110 String compInstName = componentInstanceData.getName();
111 compInstaMap.put(compInstName, compInstUniqueId);
115 result = Either.left(compInstaMap);
121 private Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeOfGroup(String groupUniqueId) {
123 Either<ImmutablePair<GroupTypeData, GraphEdge>, StorageOperationStatus> groupTypeRes = janusGraphGenericDao
124 .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.TYPE_OF, NodeTypeEnum.GroupType,
127 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
129 if (groupTypeRes.isRight()) {
130 StorageOperationStatus status = groupTypeRes.right().value();
131 log.debug("Cannot find group type associated with capability {}. Status is {}", groupUniqueId, status);
133 BeEcompErrorManager.getInstance().logBeFailedFindAssociationError("Fetch Group type", NodeTypeEnum.GroupType.getName(), groupUniqueId, String.valueOf(status));
134 return Either.right(groupTypeRes.right().value());
137 GroupTypeData groupTypeData = groupTypeRes.left().value().getKey();
139 return groupTypeOperation.getGroupTypeByUid(groupTypeData.getGroupTypeDataDefinition().getUniqueId());
144 * get all properties of the group.
146 * the propert definition is taken from the group type.
151 private Either<List<GroupProperty>, StorageOperationStatus> getGroupProperties(String groupUid) {
153 List<GroupProperty> groupPropertiesList = new ArrayList<>();
155 Either<GroupTypeDefinition, StorageOperationStatus> groupTypeOfGroupRes = getGroupTypeOfGroup(groupUid);
157 if (groupTypeOfGroupRes.isRight()) {
158 StorageOperationStatus status = groupTypeOfGroupRes.right().value();
159 return Either.right(status);
162 GroupTypeDefinition groupTypeDefinition = groupTypeOfGroupRes.left().value();
164 // Get the properties on the group type of this group
165 List<PropertyDefinition> groupTypeProperties = groupTypeDefinition.getProperties();
167 if (isEmpty(groupTypeProperties)) {
168 return Either.right(StorageOperationStatus.OK);
171 Map<String, PropertyDefinition> uidToPropDefMap = groupTypeProperties.stream().collect(Collectors.toMap(PropertyDefinition::getUniqueId, Function.identity()));
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)
178 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
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);
186 return Either.right(status);
190 List<ImmutablePair<PropertyValueData, GraphEdge>> list = propertyImplNodes.left().value();
192 return Either.right(StorageOperationStatus.OK);
195 List<String> processedProps = new ArrayList<>();
197 for (ImmutablePair<PropertyValueData, GraphEdge> propertyValue : list) {
199 PropertyValueData propertyValueData = propertyValue.getLeft();
200 String propertyValueUid = propertyValueData.getUniqueId();
201 String value = propertyValueData.getValue();
203 Either<ImmutablePair<PropertyData, GraphEdge>, StorageOperationStatus> propertyDefRes = janusGraphGenericDao
204 .getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, GraphEdgeLabels.PROPERTY_IMPL,
205 NodeTypeEnum.Property, PropertyData.class)
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;
213 return Either.right(status);
216 ImmutablePair<PropertyData, GraphEdge> propertyDefPair = propertyDefRes.left().value();
218 PropertyData propertyData = propertyDefPair.left;
219 String propertyUniqueId = propertyData.getPropertyDataDefinition().getUniqueId();
221 PropertyDefinition propertyDefinition = uidToPropDefMap.get(propertyUniqueId);
222 GroupProperty groupProperty = new GroupProperty(propertyDefinition, value, propertyValueUid);
224 processedProps.add(propertyUniqueId);
226 groupPropertiesList.add(groupProperty);
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);
240 return Either.left(groupPropertiesList);
243 public Either<List<GraphRelation>, StorageOperationStatus> dissociateAllGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String artifactId) {
245 List<GraphRelation> relations = new ArrayList<>();
246 Either<List<GraphRelation>, StorageOperationStatus> result = Either.left(relations);
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);
254 List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
255 if (isEmpty(allGroups)) {
256 return Either.right(StorageOperationStatus.OK);
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());
262 if (isNotEmpty(associatedGroups)) {
263 log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), artifactId);
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)
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;
277 return Either.right(status);
280 relations.add(deleteRelation.left().value());
286 log.debug("No group under component id {} is associated to artifact {}", componentId, artifactId);
287 return Either.right(StorageOperationStatus.OK);
292 public Either<GroupDefinition, StorageOperationStatus> getGroupFromGraph(String uniqueId, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
294 Either<GroupDefinition, StorageOperationStatus> result = null;
296 Either<GroupData, StorageOperationStatus> groupRes = janusGraphGenericDao
297 .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), uniqueId, GroupData.class)
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);
308 GroupData groupData = groupRes.left().value();
310 GroupDefinition groupDefinition = convertGroupDataToGroupDefinition(groupData);
312 Either<GroupTypeDefinition, StorageOperationStatus> groupTypeOfGroup = getGroupTypeOfGroup(uniqueId);
314 if (groupTypeOfGroup.isRight()) {
315 StorageOperationStatus status = groupTypeOfGroup.right().value();
316 log.debug("Failed to retrieve capability type of capability {}. Status is {}", uniqueId, status);
318 result = Either.right(status);
322 GroupTypeDefinition groupTypeDefinition = groupTypeOfGroup.left().value();
324 groupDefinition.setTypeUid(groupTypeDefinition.getUniqueId());
327 Either<Map<String, String>, StorageOperationStatus> membersRes = getGroupMembers(uniqueId)
329 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
330 if (membersRes.isRight()) {
331 StorageOperationStatus status = membersRes.right().value();
332 if (status != StorageOperationStatus.OK) {
333 result = Either.right(status);
337 Map<String, String> members = membersRes.left().value();
338 groupDefinition.setMembers(members);
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);
351 List<GroupProperty> properties = propertiesRes.left().value();
352 groupDefinition.convertFromGroupProperties(properties);
356 if (!skipArtifacts) {
357 Either<List<ImmutablePair<String, String>>, StorageOperationStatus> artifactsRes = getGroupArtifactsPairs(uniqueId)
359 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
360 if (artifactsRes.isRight()) {
361 StorageOperationStatus status = artifactsRes.right().value();
362 if (status != StorageOperationStatus.OK) {
363 result = Either.right(status);
367 List<String> artifactsUid = new ArrayList<>();
368 List<String> artifactsUUID = new ArrayList<>();
370 List<ImmutablePair<String, String>> list = artifactsRes.left().value();
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);
378 groupDefinition.setArtifacts(artifactsUid);
379 groupDefinition.setArtifactsUuid(artifactsUUID);
383 result = Either.left(groupDefinition);
389 public boolean isGroupExist(String groupName, boolean inTransaction) {
391 Either<List<GroupData>, JanusGraphOperationStatus> eitherGroup = null;
393 Map<String, Object> properties = new HashMap<>();
394 properties.put(GraphPropertiesDictionary.NAME.getProperty(), groupName);
396 eitherGroup = janusGraphGenericDao
397 .getByCriteria(NodeTypeEnum.Group, properties, GroupData.class);
398 return eitherGroup.isLeft() && !eitherGroup.left().value().isEmpty();
401 handleTransactionCommitRollback(inTransaction, eitherGroup);
405 protected Either<List<GroupDefinition>, StorageOperationStatus> getAllGroupsFromGraph(String componentId, NodeTypeEnum componentTypeEnum, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
407 List<GroupDefinition> groups = new ArrayList<>();
409 Either<List<ImmutablePair<GroupData, GraphEdge>>, StorageOperationStatus> childrenNodes = janusGraphGenericDao
410 .getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(componentTypeEnum), componentId, GraphEdgeLabels.GROUP, NodeTypeEnum.Group,
413 .map(DaoStatusConverter::convertJanusGraphStatusToStorageStatus);
415 if (childrenNodes.isRight()) {
416 StorageOperationStatus status = childrenNodes.right().value();
417 return Either.right(status);
420 List<ImmutablePair<GroupData, GraphEdge>> graphGroups = childrenNodes.left().value();
422 if (isEmpty(graphGroups)) {
423 return Either.right(StorageOperationStatus.NOT_FOUND);
428 for (ImmutablePair<GroupData, GraphEdge> pair : graphGroups) {
430 String groupUniqueId = pair.left.getGroupDataDefinition().getUniqueId();
431 Either<GroupDefinition, StorageOperationStatus> groupRes = this.getGroupFromGraph(groupUniqueId, skipProperties, skipMembers, skipArtifacts);
433 if (groupRes.isRight()) {
434 StorageOperationStatus status = groupRes.right().value();
435 if (status == StorageOperationStatus.NOT_FOUND) {
436 status = StorageOperationStatus.INVALID_ID;
438 return Either.right(status);
440 groups.add(groupRes.left().value());
445 return Either.left(groups);
448 private StorageOperationStatus dissociateAndAssociateGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact) {
450 Either<List<GroupDefinition>, StorageOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
451 if (allGroupsFromGraph.isRight()) {
452 return allGroupsFromGraph.right().value();
456 List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
457 if (isEmpty(allGroups)) {
458 return StorageOperationStatus.OK;
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());
464 if (isNotEmpty(associatedGroups)) {
466 log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), oldArtifactId);
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());
473 for (GroupDefinition groupDefinition : associatedGroups) {
474 UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
476 Either<GraphRelation, StorageOperationStatus> deleteRelation = janusGraphGenericDao
477 .deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF)
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;
489 Either<GraphRelation, StorageOperationStatus> createRelation = janusGraphGenericDao
490 .createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props)
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;
504 return StorageOperationStatus.OK;
507 public StorageOperationStatus dissociateAndAssociateGroupsFromArtifact(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact, boolean inTransaction) {
509 StorageOperationStatus result = null;
512 StorageOperationStatus status = this.dissociateAndAssociateGroupsFromArtifactOnGraph(componentId, componentTypeEnum, oldArtifactId, newArtifact);
514 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
518 result = StorageOperationStatus.OK;
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();
528 log.debug("Going to execute commit on graph.");
529 janusGraphGenericDao.commit();
535 private Either<List<ImmutablePair<String, String>>, JanusGraphOperationStatus> getGroupArtifactsPairs(String groupUniqueId) {
537 Either<List<ImmutablePair<String, String>>, JanusGraphOperationStatus> result = null;
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;
547 result = Either.right(status);
551 List<ImmutablePair<String, String>> artifactsList = new ArrayList<>();
552 List<ImmutablePair<ArtifactData, GraphEdge>> list = childrenNodes.left().value();
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);
563 log.debug("The artifacts list related to group {} is {}", groupUniqueId, artifactsList);
564 result = Either.left(artifactsList);
571 public StorageOperationStatus validateAndUpdatePropertyValue(GroupProperty property) {
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);
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;
590 String validValue = String.valueOf(isValid.left().value());
591 property.setValue(validValue);
592 result = StorageOperationStatus.OK;
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);
605 throw new StorageException(StorageOperationStatus.NOT_FOUND, groupId);
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);
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());
622 private void overrideCurrentPropertiesWithUpdatedProperties(Map<String, PropertyDataDefinition> currPropsByName, List<PropertyDataDefinition> toBeUpdatedProperties) {
623 toBeUpdatedProperties.forEach(prop -> currPropsByName.put(prop.getName(), prop));