package org.openecomp.sdc.be.model.operations.impl;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
+import fj.data.Either;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge;
import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
+import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.dao.utils.MapUtil;
+import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
-import org.openecomp.sdc.be.model.DataTypeDefinition;
-import org.openecomp.sdc.be.model.GroupDefinition;
-import org.openecomp.sdc.be.model.GroupProperty;
-import org.openecomp.sdc.be.model.GroupTypeDefinition;
-import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.*;
import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation;
+import org.openecomp.sdc.be.model.operations.StorageException;
import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-import org.openecomp.sdc.be.resources.data.ArtifactData;
-import org.openecomp.sdc.be.resources.data.ComponentInstanceData;
-import org.openecomp.sdc.be.resources.data.GroupData;
-import org.openecomp.sdc.be.resources.data.GroupTypeData;
-import org.openecomp.sdc.be.resources.data.PropertyData;
-import org.openecomp.sdc.be.resources.data.PropertyValueData;
-import org.openecomp.sdc.be.resources.data.UniqueIdData;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.openecomp.sdc.be.resources.data.*;
+import org.openecomp.sdc.common.log.wrappers.Logger;
import org.springframework.stereotype.Component;
-import fj.data.Either;
-
-@Component("group-operation")
-public class GroupOperation extends AbstractOperation implements IGroupOperation {
-
-
- private static Logger log = LoggerFactory.getLogger(GroupOperation.class.getName());
-
- @javax.annotation.Resource
- private PropertyOperation propertyOperation;
-
- @javax.annotation.Resource
- private GroupTypeOperation groupTypeOperation;
-
- @javax.annotation.Resource
- private ApplicationDataTypeCache dataTypeCache;
-
- private GroupDefinition convertGroupDataToGroupDefinition(GroupData groupData) {
- GroupDefinition newGroupDefinition = new GroupDefinition(groupData.getGroupDataDefinition());
- return newGroupDefinition;
- }
-
- /**
- * get members of group
- *
- * @param groupUniqueId
- * @return
- */
- private Either<Map<String, String>, TitanOperationStatus> getGroupMembers(String groupUniqueId) {
-
- Either<Map<String, String>, TitanOperationStatus> result = null;
-
- Either<List<ImmutablePair<ComponentInstanceData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_MEMBER,
- NodeTypeEnum.ResourceInstance, ComponentInstanceData.class);
-
- if (childrenNodes.isRight()) {
- TitanOperationStatus status = childrenNodes.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.OK;
- }
- result = Either.right(status);
-
- } else {
-
- Map<String, String> compInstaMap = new HashMap<>();
- List<ImmutablePair<ComponentInstanceData, GraphEdge>> list = childrenNodes.left().value();
- if (list != null) {
- for (ImmutablePair<ComponentInstanceData, GraphEdge> pair : list) {
- ComponentInstanceData componentInstanceData = pair.getKey();
-
- String compInstUniqueId = componentInstanceData.getComponentInstDataDefinition().getUniqueId();
- String compInstName = componentInstanceData.getName();
- compInstaMap.put(compInstName, compInstUniqueId);
- }
- }
-
- result = Either.left(compInstaMap);
- }
-
- return result;
- }
-
- private Either<GroupTypeDefinition, TitanOperationStatus> getGroupTypeOfGroup(String groupUniqueId) {
-
- Either<ImmutablePair<GroupTypeData, GraphEdge>, TitanOperationStatus> groupTypeRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.TYPE_OF, NodeTypeEnum.GroupType,
- GroupTypeData.class);
-
- if (groupTypeRes.isRight()) {
- TitanOperationStatus status = groupTypeRes.right().value();
- log.debug("Cannot find group type associated with capability {}. Status is {}", groupUniqueId, status);
-
- BeEcompErrorManager.getInstance().logBeFailedFindAssociationError("Fetch Group type", NodeTypeEnum.GroupType.getName(), groupUniqueId, String.valueOf(status));
- return Either.right(groupTypeRes.right().value());
- }
-
- GroupTypeData groupTypeData = groupTypeRes.left().value().getKey();
-
- return groupTypeOperation.getGroupTypeByUid(groupTypeData.getGroupTypeDataDefinition().getUniqueId());
-
- }
-
- /**
- * get all properties of the group.
- *
- * the propert definition is taken from the group type.
- *
- * @param groupUid
- * @return
- */
- private Either<List<GroupProperty>, TitanOperationStatus> getGroupProperties(String groupUid) {
-
- List<GroupProperty> groupPropertiesList = new ArrayList<>();
-
- Either<GroupTypeDefinition, TitanOperationStatus> groupTypeOfGroupRes = getGroupTypeOfGroup(groupUid);
-
- if (groupTypeOfGroupRes.isRight()) {
- TitanOperationStatus status = groupTypeOfGroupRes.right().value();
- return Either.right(status);
- }
-
- GroupTypeDefinition groupTypeDefinition = groupTypeOfGroupRes.left().value();
-
- // Get the properties on the group type of this group
- List<PropertyDefinition> groupTypeProperties = groupTypeDefinition.getProperties();
-
- if (groupTypeProperties == null || true == groupTypeProperties.isEmpty()) {
- return Either.right(TitanOperationStatus.OK);
- }
-
- Map<String, PropertyDefinition> uidToPropDefMap = groupTypeProperties.stream().collect(Collectors.toMap(p -> p.getUniqueId(), p -> p));
-
- // Find all properties values on the group
- Either<List<ImmutablePair<PropertyValueData, GraphEdge>>, TitanOperationStatus> propertyImplNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUid, GraphEdgeLabels.PROPERTY_VALUE,
- NodeTypeEnum.PropertyValue, PropertyValueData.class);
-
- if (propertyImplNodes.isRight()) {
- TitanOperationStatus status = propertyImplNodes.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- groupPropertiesList = groupTypeProperties.stream().map(p -> new GroupProperty(p, p.getDefaultValue(), null)).collect(Collectors.toList());
- return Either.left(groupPropertiesList);
- } else {
- return Either.right(status);
- }
- }
-
- List<ImmutablePair<PropertyValueData, GraphEdge>> list = propertyImplNodes.left().value();
- if (list == null || true == list.isEmpty()) {
- return Either.right(TitanOperationStatus.OK);
- }
-
- List<String> processedProps = new ArrayList<>();
-
- for (ImmutablePair<PropertyValueData, GraphEdge> propertyValue : list) {
-
- PropertyValueData propertyValueData = propertyValue.getLeft();
- String propertyValueUid = propertyValueData.getUniqueId();
- String value = propertyValueData.getValue();
-
- Either<ImmutablePair<PropertyData, GraphEdge>, TitanOperationStatus> propertyDefRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, GraphEdgeLabels.PROPERTY_IMPL,
- NodeTypeEnum.Property, PropertyData.class);
- if (propertyDefRes.isRight()) {
- TitanOperationStatus status = propertyDefRes.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
- }
- return Either.right(status);
- }
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
- ImmutablePair<PropertyData, GraphEdge> propertyDefPair = propertyDefRes.left().value();
+import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+import static org.springframework.util.CollectionUtils.isEmpty;
- PropertyData propertyData = propertyDefPair.left;
- String propertyUniqueId = propertyData.getPropertyDataDefinition().getUniqueId();
- PropertyDefinition propertyDefinition = uidToPropDefMap.get(propertyUniqueId);
- GroupProperty groupProperty = new GroupProperty(propertyDefinition, value, propertyValueUid);
+@Component
+public class GroupOperation extends AbstractOperation implements IGroupOperation {
- processedProps.add(propertyUniqueId);
- groupPropertiesList.add(groupProperty);
+ private static final Logger log = Logger.getLogger(GroupOperation.class.getName());
+ private final TitanDao titanDao;
+ private final TopologyTemplateOperation topologyTemplateOperation;
+ private final PropertyOperation propertyOperation;
+ private final GroupTypeOperation groupTypeOperation;
+ private final ApplicationDataTypeCache dataTypeCache;
- }
+ public GroupOperation(TitanDao titanDao, TopologyTemplateOperation topologyTemplateOperation, PropertyOperation propertyOperation, GroupTypeOperation groupTypeOperation, ApplicationDataTypeCache dataTypeCache) {
+ this.titanDao = titanDao;
+ this.topologyTemplateOperation = topologyTemplateOperation;
+ this.propertyOperation = propertyOperation;
+ this.groupTypeOperation = groupTypeOperation;
+ this.dataTypeCache = dataTypeCache;
+ }
- // Find all properties which does not have property value on the group.
- List<GroupProperty> leftProps = groupTypeProperties.stream()
- // filter out the group type properties which already processed
- .filter(p -> false == processedProps.contains(p.getUniqueId())).map(p -> new GroupProperty(p, p.getDefaultValue(), null)).collect(Collectors.toList());
- if (leftProps != null) {
- groupPropertiesList.addAll(leftProps);
- }
+ private GroupDefinition convertGroupDataToGroupDefinition(GroupData groupData) {
+ return new GroupDefinition(groupData.getGroupDataDefinition());
- return Either.left(groupPropertiesList);
}
- @Override
- public Either<List<GraphRelation>, TitanOperationStatus> dissociateAllGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String artifactId) {
-
- List<GraphRelation> relations = new ArrayList<>();
- Either<List<GraphRelation>, TitanOperationStatus> result = Either.left(relations);
-
- Either<List<GroupDefinition>, TitanOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
- if (allGroupsFromGraph.isRight()) {
- TitanOperationStatus status = allGroupsFromGraph.right().value();
- return Either.right(status);
- }
-
- List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
- if (allGroups == null || allGroups.isEmpty()) {
- return Either.right(TitanOperationStatus.OK);
- }
-
- // Find all groups which contains this artifact id
- List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(artifactId)).collect(Collectors.toList());
-
- if (associatedGroups != null && false == associatedGroups.isEmpty()) {
- log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(p -> p.getName()).collect(Collectors.toList()), artifactId);
+ /**
+ * get members of group
+ *
+ * @param groupUniqueId
+ * @return
+ */
+ private Either<Map<String, String>, TitanOperationStatus> getGroupMembers(String groupUniqueId) {
- UniqueIdData artifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId);
- for (GroupDefinition groupDefinition : associatedGroups) {
- UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
- Either<GraphRelation, TitanOperationStatus> deleteRelation = titanGenericDao.deleteRelation(groupData, artifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF);
- if (deleteRelation.isRight()) {
- TitanOperationStatus status = deleteRelation.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
- }
- return Either.right(status);
- }
+ Either<Map<String, String>, TitanOperationStatus> result = null;
- relations.add(deleteRelation.left().value());
- }
+ Either<List<ImmutablePair<ComponentInstanceData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_MEMBER,
+ NodeTypeEnum.ResourceInstance, ComponentInstanceData.class);
- return result;
+ if (childrenNodes.isRight()) {
+ TitanOperationStatus status = childrenNodes.right().value();
+ if (status == TitanOperationStatus.NOT_FOUND) {
+ status = TitanOperationStatus.OK;
+ }
+ result = Either.right(status);
- } else {
- log.debug("No group under component id {} is associated to artifact {}", componentId, artifactId);
- return Either.right(TitanOperationStatus.OK);
- }
+ } else {
- }
+ Map<String, String> compInstaMap = new HashMap<>();
+ List<ImmutablePair<ComponentInstanceData, GraphEdge>> list = childrenNodes.left().value();
+ if (list != null) {
+ for (ImmutablePair<ComponentInstanceData, GraphEdge> pair : list) {
+ ComponentInstanceData componentInstanceData = pair.getKey();
+
+ String compInstUniqueId = componentInstanceData.getComponentInstDataDefinition().getUniqueId();
+ String compInstName = componentInstanceData.getName();
+ compInstaMap.put(compInstName, compInstUniqueId);
+ }
+ }
- public Either<GroupDefinition, TitanOperationStatus> getGroupFromGraph(String uniqueId, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
+ result = Either.left(compInstaMap);
+ }
- Either<GroupDefinition, TitanOperationStatus> result = null;
+ return result;
+ }
- Either<GroupData, TitanOperationStatus> groupRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), uniqueId, GroupData.class);
- if (groupRes.isRight()) {
- TitanOperationStatus status = groupRes.right().value();
- log.debug("Failed to retrieve group {} from graph. Status is {}", uniqueId, status);
- BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("Fetch Group", uniqueId, String.valueOf(status));
- result = Either.right(status);
- return result;
- }
+ private Either<GroupTypeDefinition, StorageOperationStatus> getGroupTypeOfGroup(String groupUniqueId) {
- GroupData groupData = groupRes.left().value();
+ Either<ImmutablePair<GroupTypeData, GraphEdge>, StorageOperationStatus> groupTypeRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.TYPE_OF, NodeTypeEnum.GroupType,
+ GroupTypeData.class)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
- GroupDefinition groupDefinition = convertGroupDataToGroupDefinition(groupData);
+ if (groupTypeRes.isRight()) {
+ StorageOperationStatus status = groupTypeRes.right().value();
+ log.debug("Cannot find group type associated with capability {}. Status is {}", groupUniqueId, status);
- Either<GroupTypeDefinition, TitanOperationStatus> groupTypeOfGroup = getGroupTypeOfGroup(uniqueId);
+ BeEcompErrorManager.getInstance().logBeFailedFindAssociationError("Fetch Group type", NodeTypeEnum.GroupType.getName(), groupUniqueId, String.valueOf(status));
+ return Either.right(groupTypeRes.right().value());
+ }
+
+ GroupTypeData groupTypeData = groupTypeRes.left().value().getKey();
- if (groupTypeOfGroup.isRight()) {
- TitanOperationStatus status = groupTypeOfGroup.right().value();
- log.debug("Failed to retrieve capability type of capability {}. Status is {}", uniqueId, status);
+ return groupTypeOperation.getGroupTypeByUid(groupTypeData.getGroupTypeDataDefinition().getUniqueId());
- result = Either.right(status);
- return result;
- }
+ }
- GroupTypeDefinition groupTypeDefinition = groupTypeOfGroup.left().value();
-
- groupDefinition.setTypeUid(groupTypeDefinition.getUniqueId());
-
- if (false == skipMembers) {
- Either<Map<String, String>, TitanOperationStatus> membersRes = getGroupMembers(uniqueId);
- if (membersRes.isRight()) {
- TitanOperationStatus status = membersRes.right().value();
- if (status != TitanOperationStatus.OK) {
- result = Either.right(status);
- return result;
- }
- } else {
- Map<String, String> members = membersRes.left().value();
- groupDefinition.setMembers(members);
- }
- }
+ /**
+ * get all properties of the group.
+ *
+ * the propert definition is taken from the group type.
+ *
+ * @param groupUid
+ * @return
+ */
+ private Either<List<GroupProperty>, StorageOperationStatus> getGroupProperties(String groupUid) {
- if (false == skipProperties) {
- Either<List<GroupProperty>, TitanOperationStatus> propertiesRes = getGroupProperties(uniqueId);
- if (propertiesRes.isRight()) {
- TitanOperationStatus status = propertiesRes.right().value();
- if (status != TitanOperationStatus.OK) {
- result = Either.right(status);
- return result;
- }
- } else {
- List<GroupProperty> properties = propertiesRes.left().value();
- groupDefinition.convertFromGroupProperties(properties);
- }
- }
+ List<GroupProperty> groupPropertiesList = new ArrayList<>();
- if (false == skipArtifacts) {
- Either<List<ImmutablePair<String, String>>, TitanOperationStatus> artifactsRes = getGroupArtifactsPairs(uniqueId);
- if (artifactsRes.isRight()) {
- TitanOperationStatus status = artifactsRes.right().value();
- if (status != TitanOperationStatus.OK) {
- result = Either.right(status);
- return result;
- }
- } else {
- List<String> artifactsUid = new ArrayList<>();
- List<String> artifactsUUID = new ArrayList<>();
-
- List<ImmutablePair<String, String>> list = artifactsRes.left().value();
- if (list != null) {
- for (ImmutablePair<String, String> pair : list) {
- String uid = pair.left;
- String UUID = pair.right;
- artifactsUid.add(uid);
- artifactsUUID.add(UUID);
- }
- groupDefinition.setArtifacts(artifactsUid);
- groupDefinition.setArtifactsUuid(artifactsUUID);
- }
- }
- }
- result = Either.left(groupDefinition);
+ Either<GroupTypeDefinition, StorageOperationStatus> groupTypeOfGroupRes = getGroupTypeOfGroup(groupUid);
+
+ if (groupTypeOfGroupRes.isRight()) {
+ StorageOperationStatus status = groupTypeOfGroupRes.right().value();
+ return Either.right(status);
+ }
- return result;
+ GroupTypeDefinition groupTypeDefinition = groupTypeOfGroupRes.left().value();
- }
+ // Get the properties on the group type of this group
+ List<PropertyDefinition> groupTypeProperties = groupTypeDefinition.getProperties();
- @Override
- public boolean isGroupExist(String groupName, boolean inTransaction) {
+ if (isEmpty(groupTypeProperties)) {
+ return Either.right(StorageOperationStatus.OK);
+ }
+
+ Map<String, PropertyDefinition> uidToPropDefMap = groupTypeProperties.stream().collect(Collectors.toMap(PropertyDefinition::getUniqueId, Function.identity()));
+
+ // Find all properties values on the group
+ Either<List<ImmutablePair<PropertyValueData, GraphEdge>>, StorageOperationStatus> propertyImplNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUid, GraphEdgeLabels.PROPERTY_VALUE,
+ NodeTypeEnum.PropertyValue, PropertyValueData.class)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+
+ if (propertyImplNodes.isRight()) {
+ StorageOperationStatus status = propertyImplNodes.right().value();
+ if (status == StorageOperationStatus.NOT_FOUND) {
+ groupPropertiesList = groupTypeProperties.stream().map(p -> new GroupProperty(p, p.getDefaultValue(), null)).collect(Collectors.toList());
+ return Either.left(groupPropertiesList);
+ } else {
+ return Either.right(status);
+ }
+ }
+
+ List<ImmutablePair<PropertyValueData, GraphEdge>> list = propertyImplNodes.left().value();
+ if (isEmpty(list)) {
+ return Either.right(StorageOperationStatus.OK);
+ }
- Either<List<GroupData>, TitanOperationStatus> eitherGroup = null;
- try {
- Map<String, Object> properties = new HashMap<>();
- properties.put(GraphPropertiesDictionary.NAME.getProperty(), groupName);
+ List<String> processedProps = new ArrayList<>();
+
+ for (ImmutablePair<PropertyValueData, GraphEdge> propertyValue : list) {
+
+ PropertyValueData propertyValueData = propertyValue.getLeft();
+ String propertyValueUid = propertyValueData.getUniqueId();
+ String value = propertyValueData.getValue();
+
+ Either<ImmutablePair<PropertyData, GraphEdge>, StorageOperationStatus> propertyDefRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.PropertyValue), propertyValueUid, GraphEdgeLabels.PROPERTY_IMPL,
+ NodeTypeEnum.Property, PropertyData.class)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+ if (propertyDefRes.isRight()) {
+ StorageOperationStatus status = propertyDefRes.right().value();
+ if (status == StorageOperationStatus.NOT_FOUND) {
+ status = StorageOperationStatus.INVALID_ID;
+ }
+ return Either.right(status);
+ }
- eitherGroup = titanGenericDao.getByCriteria(NodeTypeEnum.Group, properties, GroupData.class);
- return eitherGroup.isLeft() && !eitherGroup.left().value().isEmpty();
+ ImmutablePair<PropertyData, GraphEdge> propertyDefPair = propertyDefRes.left().value();
- } finally {
- handleTransactionCommitRollback(inTransaction, eitherGroup);
- }
- }
+ PropertyData propertyData = propertyDefPair.left;
+ String propertyUniqueId = propertyData.getPropertyDataDefinition().getUniqueId();
- protected Either<List<GroupDefinition>, TitanOperationStatus> getAllGroupsFromGraph(String componentId, NodeTypeEnum componentTypeEnum, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
+ PropertyDefinition propertyDefinition = uidToPropDefMap.get(propertyUniqueId);
+ GroupProperty groupProperty = new GroupProperty(propertyDefinition, value, propertyValueUid);
- List<GroupDefinition> groups = new ArrayList<GroupDefinition>();
+ processedProps.add(propertyUniqueId);
- Either<List<ImmutablePair<GroupData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(componentTypeEnum), componentId, GraphEdgeLabels.GROUP, NodeTypeEnum.Group,
- GroupData.class);
+ groupPropertiesList.add(groupProperty);
- if (childrenNodes.isRight()) {
- TitanOperationStatus status = childrenNodes.right().value();
- return Either.right(status);
- }
+ }
- List<ImmutablePair<GroupData, GraphEdge>> graphGroups = childrenNodes.left().value();
+ // Find all properties which does not have property value on the group.
+ List<GroupProperty> leftProps = groupTypeProperties.stream()
+ // filter out the group type properties which already processed
+ .filter(p -> !processedProps.contains(p.getUniqueId()))
+ .map(p -> new GroupProperty(p, p.getDefaultValue(), null))
+ .collect(Collectors.toList());
+ if (leftProps != null) {
+ groupPropertiesList.addAll(leftProps);
+ }
+
+ return Either.left(groupPropertiesList);
+ }
+
+ @Override
+ public Either<List<GraphRelation>, StorageOperationStatus> dissociateAllGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String artifactId) {
+
+ List<GraphRelation> relations = new ArrayList<>();
+ Either<List<GraphRelation>, StorageOperationStatus> result = Either.left(relations);
+
+ Either<List<GroupDefinition>, StorageOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
+ if (allGroupsFromGraph.isRight()) {
+ StorageOperationStatus status = allGroupsFromGraph.right().value();
+ return Either.right(status);
+ }
+
+ List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
+ if (isEmpty(allGroups)) {
+ return Either.right(StorageOperationStatus.OK);
+ }
+
+ // Find all groups which contains this artifact id
+ List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(artifactId)).collect(Collectors.toList());
+
+ if (isNotEmpty(associatedGroups)) {
+ log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), artifactId);
+
+ UniqueIdData artifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, artifactId);
+ for (GroupDefinition groupDefinition : associatedGroups) {
+ UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
+ Either<GraphRelation, StorageOperationStatus> deleteRelation = titanGenericDao.deleteRelation(groupData, artifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+ if (deleteRelation.isRight()) {
+ StorageOperationStatus status = deleteRelation.right().value();
+ if (status == StorageOperationStatus.NOT_FOUND) {
+ status = StorageOperationStatus.INVALID_ID;
+ }
+ return Either.right(status);
+ }
+
+ relations.add(deleteRelation.left().value());
+ }
+
+ return result;
+
+ } else {
+ log.debug("No group under component id {} is associated to artifact {}", componentId, artifactId);
+ return Either.right(StorageOperationStatus.OK);
+ }
+
+ }
+
+ public Either<GroupDefinition, StorageOperationStatus> getGroupFromGraph(String uniqueId, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
+
+ Either<GroupDefinition, StorageOperationStatus> result = null;
+
+ Either<GroupData, StorageOperationStatus> groupRes = titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), uniqueId, GroupData.class)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+ if (groupRes.isRight()) {
+ StorageOperationStatus status = groupRes.right().value();
+ log.debug("Failed to retrieve group {} from graph. Status is {}", uniqueId, status);
+ BeEcompErrorManager.getInstance().logBeFailedRetrieveNodeError("Fetch Group", uniqueId, String.valueOf(status));
+ result = Either.right(status);
+ return result;
+ }
+
+ GroupData groupData = groupRes.left().value();
+
+ GroupDefinition groupDefinition = convertGroupDataToGroupDefinition(groupData);
+
+ Either<GroupTypeDefinition, StorageOperationStatus> groupTypeOfGroup = getGroupTypeOfGroup(uniqueId);
+
+ if (groupTypeOfGroup.isRight()) {
+ StorageOperationStatus status = groupTypeOfGroup.right().value();
+ log.debug("Failed to retrieve capability type of capability {}. Status is {}", uniqueId, status);
+
+ result = Either.right(status);
+ return result;
+ }
+
+ GroupTypeDefinition groupTypeDefinition = groupTypeOfGroup.left().value();
+
+ groupDefinition.setTypeUid(groupTypeDefinition.getUniqueId());
+
+ if (!skipMembers) {
+ Either<Map<String, String>, StorageOperationStatus> membersRes = getGroupMembers(uniqueId)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+ if (membersRes.isRight()) {
+ StorageOperationStatus status = membersRes.right().value();
+ if (status != StorageOperationStatus.OK) {
+ result = Either.right(status);
+ return result;
+ }
+ } else {
+ Map<String, String> members = membersRes.left().value();
+ groupDefinition.setMembers(members);
+ }
+ }
+
+ if (!skipProperties) {
+ Either<List<GroupProperty>, StorageOperationStatus> propertiesRes = getGroupProperties(uniqueId);
+ if (propertiesRes.isRight()) {
+ StorageOperationStatus status = propertiesRes.right().value();
+ if (status != StorageOperationStatus.OK) {
+ result = Either.right(status);
+ return result;
+ }
+ } else {
+ List<GroupProperty> properties = propertiesRes.left().value();
+ groupDefinition.convertFromGroupProperties(properties);
+ }
+ }
+
+ if (!skipArtifacts) {
+ Either<List<ImmutablePair<String, String>>, StorageOperationStatus> artifactsRes = getGroupArtifactsPairs(uniqueId)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+ if (artifactsRes.isRight()) {
+ StorageOperationStatus status = artifactsRes.right().value();
+ if (status != StorageOperationStatus.OK) {
+ result = Either.right(status);
+ return result;
+ }
+ } else {
+ List<String> artifactsUid = new ArrayList<>();
+ List<String> artifactsUUID = new ArrayList<>();
+
+ List<ImmutablePair<String, String>> list = artifactsRes.left().value();
+ if (list != null) {
+ for (ImmutablePair<String, String> pair : list) {
+ String uid = pair.left;
+ String UUID = pair.right;
+ artifactsUid.add(uid);
+ artifactsUUID.add(UUID);
+ }
+ groupDefinition.setArtifacts(artifactsUid);
+ groupDefinition.setArtifactsUuid(artifactsUUID);
+ }
+ }
+ }
+ result = Either.left(groupDefinition);
+
+ return result;
+
+ }
+
+ @Override
+ public boolean isGroupExist(String groupName, boolean inTransaction) {
+
+ Either<List<GroupData>, TitanOperationStatus> eitherGroup = null;
+ try {
+ Map<String, Object> properties = new HashMap<>();
+ properties.put(GraphPropertiesDictionary.NAME.getProperty(), groupName);
+
+ eitherGroup = titanGenericDao.getByCriteria(NodeTypeEnum.Group, properties, GroupData.class);
+ return eitherGroup.isLeft() && !eitherGroup.left().value().isEmpty();
+
+ } finally {
+ handleTransactionCommitRollback(inTransaction, eitherGroup);
+ }
+ }
+
+ protected Either<List<GroupDefinition>, StorageOperationStatus> getAllGroupsFromGraph(String componentId, NodeTypeEnum componentTypeEnum, boolean skipProperties, boolean skipMembers, boolean skipArtifacts) {
+
+ List<GroupDefinition> groups = new ArrayList<>();
+
+ Either<List<ImmutablePair<GroupData, GraphEdge>>, StorageOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(componentTypeEnum), componentId, GraphEdgeLabels.GROUP, NodeTypeEnum.Group,
+ GroupData.class)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+
+ if (childrenNodes.isRight()) {
+ StorageOperationStatus status = childrenNodes.right().value();
+ return Either.right(status);
+ }
+
+ List<ImmutablePair<GroupData, GraphEdge>> graphGroups = childrenNodes.left().value();
+
+ if (isEmpty(graphGroups)) {
+ return Either.right(StorageOperationStatus.NOT_FOUND);
+ }
- if (graphGroups == null || true == graphGroups.isEmpty()) {
- return Either.right(TitanOperationStatus.NOT_FOUND);
- }
- // Consumer<String> consumer = (x) -> getGroup(x);
- // StreamUtils.takeWhile(graphGroups.stream().map(p ->
- // p.left.getUniqueId()), consumer);
for (ImmutablePair<GroupData, GraphEdge> pair : graphGroups) {
- String groupUniqueId = pair.left.getGroupDataDefinition().getUniqueId();
- Either<GroupDefinition, TitanOperationStatus> groupRes = this.getGroupFromGraph(groupUniqueId, skipProperties, skipMembers, skipArtifacts);
+ String groupUniqueId = pair.left.getGroupDataDefinition().getUniqueId();
+ Either<GroupDefinition, StorageOperationStatus> groupRes = this.getGroupFromGraph(groupUniqueId, skipProperties, skipMembers, skipArtifacts);
- if (groupRes.isRight()) {
- TitanOperationStatus status = groupRes.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
- }
- return Either.right(status);
- } else {
- groups.add(groupRes.left().value());
- }
+ if (groupRes.isRight()) {
+ StorageOperationStatus status = groupRes.right().value();
+ if (status == StorageOperationStatus.NOT_FOUND) {
+ status = StorageOperationStatus.INVALID_ID;
+ }
+ return Either.right(status);
+ } else {
+ groups.add(groupRes.left().value());
+ }
- }
+ }
- return Either.left(groups);
- }
+ return Either.left(groups);
+ }
- private TitanOperationStatus dissociateAndAssociateGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact) {
+ private StorageOperationStatus dissociateAndAssociateGroupsFromArtifactOnGraph(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact) {
- Either<List<GroupDefinition>, TitanOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
+ Either<List<GroupDefinition>, StorageOperationStatus> allGroupsFromGraph = getAllGroupsFromGraph(componentId, componentTypeEnum, true, true, false);
if (allGroupsFromGraph.isRight()) {
- TitanOperationStatus status = allGroupsFromGraph.right().value();
- return status;
- }
+ return allGroupsFromGraph.right().value();
- List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
- if (allGroups == null || allGroups.isEmpty()) {
- return TitanOperationStatus.OK;
}
- // Find all groups which contains this artifact id
- List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(oldArtifactId)).collect(Collectors.toList());
-
- if (associatedGroups != null && false == associatedGroups.isEmpty()) {
-
- log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(p -> p.getName()).collect(Collectors.toList()), oldArtifactId);
-
- UniqueIdData oldArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, oldArtifactId);
- UniqueIdData newArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, newArtifact.getArtifactDataDefinition().getUniqueId());
- Map<String, Object> props = new HashMap<String, Object>();
- props.put(GraphPropertiesDictionary.NAME.getProperty(), newArtifactData.getLabel());
-
- for (GroupDefinition groupDefinition : associatedGroups) {
- UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
-
- Either<GraphRelation, TitanOperationStatus> deleteRelation = titanGenericDao.deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF);
- log.trace("After dissociate group {} from artifact {}" , groupDefinition.getName(), oldArtifactId);
- if (deleteRelation.isRight()) {
- TitanOperationStatus status = deleteRelation.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
- }
- return status;
- }
-
- Either<GraphRelation, TitanOperationStatus> createRelation = titanGenericDao.createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props);
- log.trace("After associate group {} to artifact {}" , groupDefinition.getName(), newArtifact.getUniqueIdKey());
- if (createRelation.isRight()) {
- TitanOperationStatus status = createRelation.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.INVALID_ID;
- }
- return status;
- }
- }
-
+ List<GroupDefinition> allGroups = allGroupsFromGraph.left().value();
+ if (isEmpty(allGroups)) {
+ return StorageOperationStatus.OK;
+ }
+
+ // Find all groups which contains this artifact id
+ List<GroupDefinition> associatedGroups = allGroups.stream().filter(p -> p.getArtifacts() != null && p.getArtifacts().contains(oldArtifactId)).collect(Collectors.toList());
+
+ if (isNotEmpty(associatedGroups)) {
+
+ log.debug("The groups {} contains the artifact {}", associatedGroups.stream().map(GroupDataDefinition::getName).collect(Collectors.toList()), oldArtifactId);
+
+ UniqueIdData oldArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, oldArtifactId);
+ UniqueIdData newArtifactData = new UniqueIdData(NodeTypeEnum.ArtifactRef, newArtifact.getArtifactDataDefinition().getUniqueId());
+ Map<String, Object> props = new HashMap<>();
+ props.put(GraphPropertiesDictionary.NAME.getProperty(), newArtifactData.getLabel());
+
+ for (GroupDefinition groupDefinition : associatedGroups) {
+ UniqueIdData groupData = new UniqueIdData(NodeTypeEnum.Group, groupDefinition.getUniqueId());
+
+ Either<GraphRelation, StorageOperationStatus> deleteRelation = titanGenericDao.deleteRelation(groupData, oldArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+ log.trace("After dissociate group {} from artifact {}" , groupDefinition.getName(), oldArtifactId);
+ if (deleteRelation.isRight()) {
+ StorageOperationStatus status = deleteRelation.right().value();
+ if (status == StorageOperationStatus.NOT_FOUND) {
+ status = StorageOperationStatus.INVALID_ID;
+ }
+ return status;
+ }
+
+ Either<GraphRelation, StorageOperationStatus> createRelation = titanGenericDao.createRelation(groupData, newArtifactData, GraphEdgeLabels.GROUP_ARTIFACT_REF, props)
+ .right()
+ .map(DaoStatusConverter::convertTitanStatusToStorageStatus);
+ log.trace("After associate group {} to artifact {}" , groupDefinition.getName(), newArtifact.getUniqueIdKey());
+ if (createRelation.isRight()) {
+ StorageOperationStatus status = createRelation.right().value();
+ if (status == StorageOperationStatus.NOT_FOUND) {
+ status = StorageOperationStatus.INVALID_ID;
+ }
+ return status;
+ }
+ }
+
+ }
+ return StorageOperationStatus.OK;
+ }
+
+ @Override
+ public StorageOperationStatus dissociateAndAssociateGroupsFromArtifact(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact, boolean inTransaction) {
+
+ StorageOperationStatus result = null;
+
+ try {
+ StorageOperationStatus status = this.dissociateAndAssociateGroupsFromArtifactOnGraph(componentId, componentTypeEnum, oldArtifactId, newArtifact);
+
+ if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
+ return status;
+ }
+
+ result = StorageOperationStatus.OK;
+ return result;
+
+ } finally {
+ if (!inTransaction) {
+ if (result == null || result != StorageOperationStatus.OK) {
+ log.debug("Going to execute rollback on graph.");
+ BeEcompErrorManager.getInstance().logBeExecuteRollbackError("Rollback on graph");
+ titanGenericDao.rollback();
+ } else {
+ log.debug("Going to execute commit on graph.");
+ titanGenericDao.commit();
+ }
+ }
+ }
+ }
+
+ private Either<List<ImmutablePair<String, String>>, TitanOperationStatus> getGroupArtifactsPairs(String groupUniqueId) {
+
+ Either<List<ImmutablePair<String, String>>, TitanOperationStatus> result = null;
+
+ Either<List<ImmutablePair<ArtifactData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF,
+ NodeTypeEnum.ArtifactRef, ArtifactData.class);
+ if (childrenNodes.isRight()) {
+ TitanOperationStatus status = childrenNodes.right().value();
+ if (status == TitanOperationStatus.NOT_FOUND) {
+ status = TitanOperationStatus.OK;
+ }
+ result = Either.right(status);
+
+ } else {
+
+ List<ImmutablePair<String, String>> artifactsList = new ArrayList<>();
+ List<ImmutablePair<ArtifactData, GraphEdge>> list = childrenNodes.left().value();
+ if (list != null) {
+ for (ImmutablePair<ArtifactData, GraphEdge> pair : list) {
+ ArtifactData artifactData = pair.getKey();
+ String uniqueId = artifactData.getArtifactDataDefinition().getUniqueId();
+ String UUID = artifactData.getArtifactDataDefinition().getArtifactUUID();
+ ImmutablePair<String, String> artifact = new ImmutablePair<>(uniqueId, UUID);
+ artifactsList.add(artifact);
+ }
+ }
+
+ log.debug("The artifacts list related to group {} is {}", groupUniqueId, artifactsList);
+ result = Either.left(artifactsList);
+ }
+
+ return result;
+
+ }
+
+ @Override
+ public StorageOperationStatus validateAndUpdatePropertyValue(GroupProperty property) {
+
+ StorageOperationStatus result = null;
+ String innerType = property.getSchema() == null ? null : property.getSchema().getProperty() == null ? null : property.getSchema().getProperty().getType();
+ Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = dataTypeCache.getAll();
+ Either<Object, Boolean> isValid = null;
+ if (allDataTypes.isRight()) {
+ TitanOperationStatus status = allDataTypes.right().value();
+ log.debug("Failed to fetch data types from cache. Status is {}. ", status);
+ result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
+ }
+ if(result == null){
+ isValid = propertyOperation.validateAndUpdatePropertyValue(property.getType(), property.getValue(), innerType, allDataTypes.left().value());
+ if(isValid.isRight()){
+ log.debug("Failed to validate property value {}. Status is {}. ", property.getValue(), StorageOperationStatus.INVALID_PROPERTY);
+ result = StorageOperationStatus.INVALID_PROPERTY;
+ }
+ }
+ if(result == null){
+ String validValue = String.valueOf(isValid.left().value());
+ property.setValue(validValue);
+ result = StorageOperationStatus.OK;
+ }
+ return result;
+ }
+
+ public StorageOperationStatus updateGroupProperties(org.openecomp.sdc.be.model.Component containerComponent, String groupId, List<PropertyDataDefinition> propertiesToUpdate) {
+ log.debug("#updateGroupProperties - updating the properties of group {} in component {}", groupId, containerComponent.getUniqueId());
+ Optional<GroupDefinition> group = containerComponent.getGroupById(groupId);
+ if (group.isPresent()){
+ return titanDao.getVertexById(containerComponent.getUniqueId(), JsonParseFlagEnum.NoParse)
+ .either(containerVertex -> updateGroupProperties(containerVertex, group.get(), propertiesToUpdate),
+ DaoStatusConverter::convertTitanStatusToStorageStatus);
+ } else {
+ throw new StorageException(StorageOperationStatus.NOT_FOUND, groupId);
}
- return TitanOperationStatus.OK;
}
- @Override
- public StorageOperationStatus dissociateAndAssociateGroupsFromArtifact(String componentId, NodeTypeEnum componentTypeEnum, String oldArtifactId, ArtifactData newArtifact, boolean inTransaction) {
-
- StorageOperationStatus result = null;
-
- try {
- TitanOperationStatus status = this.dissociateAndAssociateGroupsFromArtifactOnGraph(componentId, componentTypeEnum, oldArtifactId, newArtifact);
-
- if (status != TitanOperationStatus.OK && status != TitanOperationStatus.NOT_FOUND) {
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
- return result;
- }
-
- result = StorageOperationStatus.OK;
- return result;
-
- } finally {
- if (false == inTransaction) {
- if (result == null || result != StorageOperationStatus.OK) {
- log.debug("Going to execute rollback on graph.");
- BeEcompErrorManager.getInstance().logBeExecuteRollbackError("Rollback on graph");
- titanGenericDao.rollback();
- } else {
- log.debug("Going to execute commit on graph.");
- titanGenericDao.commit();
- }
- }
- }
+ private StorageOperationStatus updateGroupProperties(GraphVertex container, GroupDefinition group, List<PropertyDataDefinition> propertiesToUpdate) {
+ List<PropertyDataDefinition> groupProperties = group.getProperties();
+ List<PropertyDataDefinition> updatedGroupProperties = updateGroupProperties(groupProperties, propertiesToUpdate);
+ group.setProperties(updatedGroupProperties);
+ return topologyTemplateOperation.updateGroupOfToscaElement(container, group);
}
- private Either<List<ImmutablePair<String, String>>, TitanOperationStatus> getGroupArtifactsPairs(String groupUniqueId) {
-
- Either<List<ImmutablePair<String, String>>, TitanOperationStatus> result = null;
-
- Either<List<ImmutablePair<ArtifactData, GraphEdge>>, TitanOperationStatus> childrenNodes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.Group), groupUniqueId, GraphEdgeLabels.GROUP_ARTIFACT_REF,
- NodeTypeEnum.ArtifactRef, ArtifactData.class);
- if (childrenNodes.isRight()) {
- TitanOperationStatus status = childrenNodes.right().value();
- if (status == TitanOperationStatus.NOT_FOUND) {
- status = TitanOperationStatus.OK;
- }
- result = Either.right(status);
-
- } else {
-
- List<ImmutablePair<String, String>> artifactsList = new ArrayList<>();
- List<ImmutablePair<ArtifactData, GraphEdge>> list = childrenNodes.left().value();
- if (list != null) {
- for (ImmutablePair<ArtifactData, GraphEdge> pair : list) {
- ArtifactData artifactData = pair.getKey();
- String uniqueId = artifactData.getArtifactDataDefinition().getUniqueId();
- String UUID = artifactData.getArtifactDataDefinition().getArtifactUUID();
- ImmutablePair<String, String> artifact = new ImmutablePair<String, String>(uniqueId, UUID);
- artifactsList.add(artifact);
- }
- }
-
- log.debug("The artifacts list related to group {} is {}", groupUniqueId, artifactsList);
- result = Either.left(artifactsList);
- }
-
- return result;
-
+ private List<PropertyDataDefinition> updateGroupProperties(List<PropertyDataDefinition> currentGroupProperties, List<PropertyDataDefinition> toBeUpdatedProperties) {
+ Map<String, PropertyDataDefinition> currPropsByName = MapUtil.toMap(currentGroupProperties, PropertyDataDefinition::getName);
+ overrideCurrentPropertiesWithUpdatedProperties(currPropsByName, toBeUpdatedProperties);
+ return new ArrayList<>(currPropsByName.values());
}
- @Override
- public StorageOperationStatus validateAndUpdatePropertyValue(GroupProperty property) {
-
- StorageOperationStatus result = null;
- String innerType = property.getSchema() == null ? null : property.getSchema().getProperty() == null ? null : property.getSchema().getProperty().getType();
- Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = dataTypeCache.getAll();
- Either<Object, Boolean> isValid = null;
- if (allDataTypes.isRight()) {
- TitanOperationStatus status = allDataTypes.right().value();
- log.debug("Failed to fetch data types from cache. Status is {}. ", status);
- result = DaoStatusConverter.convertTitanStatusToStorageStatus(status);
- }
- if(result == null){
- isValid = propertyOperation.validateAndUpdatePropertyValue(property.getType(), property.getValue(), innerType, allDataTypes.left().value());
- if(isValid.isRight()){
- log.debug("Failed to validate property value {}. Status is {}. ", property.getValue(), StorageOperationStatus.INVALID_PROPERTY);
- result = StorageOperationStatus.INVALID_PROPERTY;
- }
- }
- if(result == null){
- String validValue = String.valueOf(isValid.left().value());
- property.setValue(validValue);
- result = StorageOperationStatus.OK;
- }
- return result;
+ private void overrideCurrentPropertiesWithUpdatedProperties(Map<String, PropertyDataDefinition> currPropsByName, List<PropertyDataDefinition> toBeUpdatedProperties) {
+ toBeUpdatedProperties.forEach(prop -> currPropsByName.put(prop.getName(), prop));
}
+
}
Code Review / sdc.git / blobdiff