import static org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR;
import fj.data.Either;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
import java.util.Optional;
-import org.apache.commons.lang3.StringUtils;
import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
+import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
+import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
import org.openecomp.sdc.be.components.impl.utils.NodeFilterConstraintAction;
import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
return Optional.ofNullable(result.left().value());
}
+ private String getComponentInstancePropertyType(Component component, String componentInstanceId, String propertyName) {
+ List<ComponentInstanceProperty> componentInstanceProperties = component.getComponentInstancesProperties().get(componentInstanceId);
+ if (!componentInstanceProperties.isEmpty()) {
+ for (ComponentInstanceProperty componentInstanceProperty : componentInstanceProperties) {
+ if (componentInstanceProperty.getName().equals(propertyName)) {
+ return componentInstanceProperty.getType();
+ }
+ }
+ }
+ return null;
+ }
+
public Optional<CINodeFilterDataDefinition> addNodeFilter(final String componentId, final String componentInstanceId,
final NodeFilterConstraintAction action, final String propertyName,
final String constraint, final boolean shouldLock,
throws BusinessLogicException {
final Component component = getComponent(componentId);
CINodeFilterDataDefinition nodeFilterDataDefinition = validateAndReturnNodeFilterDefinition(componentInstanceId, action, constraint,
- component, nodeFilterConstraintType);
+ component, nodeFilterConstraintType, capabilityName);
boolean wasLocked = false;
try {
if (shouldLock) {
final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
requirementNodeFilterPropertyDataDefinition.setName(propertyName);
requirementNodeFilterPropertyDataDefinition.setConstraints(Collections.singletonList(constraint));
+ requirementNodeFilterPropertyDataDefinition.setType(getComponentInstancePropertyType(component, componentInstanceId, propertyName));
final Either<CINodeFilterDataDefinition, StorageOperationStatus> result = addNewNodeFilter(componentId, componentInstanceId,
nodeFilterConstraintType, nodeFilterDataDefinition, requirementNodeFilterPropertyDataDefinition, capabilityName);
if (result.isRight()) {
throws BusinessLogicException {
final Component component = getComponent(componentId);
CINodeFilterDataDefinition nodeFilterDataDefinition = validateAndReturnNodeFilterDefinition(componentInstanceId, action, constraint,
- component, nodeFilterConstraintType);
+ component, nodeFilterConstraintType, "");
boolean wasLocked = false;
try {
if (shouldLock) {
private CINodeFilterDataDefinition validateAndReturnNodeFilterDefinition(final String componentInstanceId,
final NodeFilterConstraintAction action, final String constraint,
final Component component,
- final NodeFilterConstraintType nodeFilterConstraintType)
+ final NodeFilterConstraintType nodeFilterConstraintType,
+ final String capabilityName)
throws BusinessLogicException {
- validateNodeFilter(component, componentInstanceId, action, constraint, nodeFilterConstraintType);
+ validateNodeFilter(component, componentInstanceId, action, constraint, nodeFilterConstraintType, capabilityName);
final Optional<CINodeFilterDataDefinition> cINodeFilterDataDefinition = getCiNodeFilterDataDefinition(componentInstanceId, component);
if (!cINodeFilterDataDefinition.isPresent()) {
throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND));
}
private void validateNodeFilter(final Component component, final String componentInstanceId, final NodeFilterConstraintAction action,
- final String constraint, final NodeFilterConstraintType nodeFilterConstraintType) throws BusinessLogicException {
+ final String constraint, final NodeFilterConstraintType nodeFilterConstraintType, final String capabilityName) throws BusinessLogicException {
final Either<Boolean, ResponseFormat> response = nodeFilterValidator
- .validateFilter(component, componentInstanceId, Collections.singletonList(constraint), action, nodeFilterConstraintType);
+ .validateFilter(component, componentInstanceId, Collections.singletonList(constraint), action, nodeFilterConstraintType, capabilityName);
if (response.isRight()) {
throw new BusinessLogicException(
componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
}
return addNodeFilter(componentId.toLowerCase(), componentInstanceId, NodeFilterConstraintAction.ADD, uiConstraint.getServicePropertyName(),
new ConstraintConvertor().convert(uiConstraint), true, componentTypeEnum, nodeFilterConstraintType,
- StringUtils.isEmpty(uiConstraint.getCapabilityName()) ? "" : uiConstraint.getCapabilityName());
+ uiConstraint.getCapabilityName());
+ }
+
+ public StorageOperationStatus associateNodeFilterToComponentInstance(final String componentId,
+ final Map<String, UploadNodeFilterInfo> instNodeFilter) {
+ for (Entry<String, UploadNodeFilterInfo> filter : instNodeFilter.entrySet()) {
+ String componentInstanceId = filter.getKey();
+ CINodeFilterDataDefinition ciNodeFilterDataDefinition = new CINodeFilterUtils()
+ .getNodeFilterDataDefinition(filter.getValue(), componentInstanceId);
+ Either<CINodeFilterDataDefinition, StorageOperationStatus> nodeFilter = nodeFilterOperation.createNodeFilter(componentId,
+ componentInstanceId);
+ if (nodeFilter.isRight()) {
+ LOGGER.error(BUSINESS_PROCESS_ERROR, "Failed to Create Node filter on component instance with id {}",
+ filter.getKey());
+ return nodeFilter.right().value();
+ }
+
+ //associate node filter properties to component instance
+ List<RequirementNodeFilterPropertyDataDefinition> properties = ciNodeFilterDataDefinition.getProperties()
+ .getListToscaDataDefinition();
+ if (!properties.isEmpty()) {
+ final Component component;
+ try {
+ component = getComponent(componentId);
+ } catch (BusinessLogicException e) {
+ throw new ComponentException(e.getResponseFormat());
+ }
+ properties.forEach(property -> {
+ String propertyType = getComponentInstancePropertyType(component, componentInstanceId, property.getName());
+ RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition =
+ getRequirementNodeFilterPropertyDataDefinition(property);
+ requirementNodeFilterPropertyDataDefinition.setType(propertyType);
+ Either<CINodeFilterDataDefinition, StorageOperationStatus> nodeFilterProperty = nodeFilterOperation
+ .addNewProperty(componentId, componentInstanceId, nodeFilter.left().value(), requirementNodeFilterPropertyDataDefinition);
+ if (nodeFilterProperty.isRight()) {
+ throw new ComponentException(
+ componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(nodeFilterProperty.right().value()),
+ componentInstanceId));
+ }
+ });
+ }
+
+ //associate node filter capabilities to component instance
+ List<RequirementNodeFilterCapabilityDataDefinition> capabilities = ciNodeFilterDataDefinition.getCapabilities()
+ .getListToscaDataDefinition();
+ if (!capabilities.isEmpty()) {
+ capabilities.forEach(capability -> {
+ RequirementNodeFilterCapabilityDataDefinition requirementNodeFilterCapabilityDataDefinition =
+ new RequirementNodeFilterCapabilityDataDefinition();
+ requirementNodeFilterCapabilityDataDefinition.setName(capability.getName());
+ requirementNodeFilterCapabilityDataDefinition.setProperties(getProperties(capability.getProperties()));
+ Either<CINodeFilterDataDefinition, StorageOperationStatus> nodeFilterCapability = nodeFilterOperation
+ .addNewCapabilities(componentId, componentInstanceId, nodeFilter.left().value(),
+ requirementNodeFilterCapabilityDataDefinition);
+ if (nodeFilterCapability.isRight()) {
+ throw new ComponentException(
+ componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(nodeFilterCapability.right().value()),
+ componentInstanceId));
+ }
+ });
+ }
+ }
+ return StorageOperationStatus.OK;
+ }
+
+ private List<String> getNodeFilterConstraints(String name, List<String> value) {
+ List<String> constraints = new ArrayList<>();
+ constraints.add(name + ":\n " + value.get(0));
+ return constraints;
+ }
+
+ private ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> getProperties(ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties) {
+ ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> updatedProperties = new ListDataDefinition<>();
+ properties.getListToscaDataDefinition().forEach(property -> {
+ RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition = getRequirementNodeFilterPropertyDataDefinition(
+ property);
+ updatedProperties.add(requirementNodeFilterPropertyDataDefinition);
+ });
+ return updatedProperties;
+ }
+
+ private RequirementNodeFilterPropertyDataDefinition getRequirementNodeFilterPropertyDataDefinition(
+ RequirementNodeFilterPropertyDataDefinition property) {
+ RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
+ requirementNodeFilterPropertyDataDefinition.setName(property.getName());
+ requirementNodeFilterPropertyDataDefinition.setConstraints(getNodeFilterConstraints(property.getName(), property.getConstraints()));
+ return requirementNodeFilterPropertyDataDefinition;
}
}