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 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.datamodel.utils.ConstraintConvertor;
import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyFilterDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
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.dto.FilterConstraintDto;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
+import org.openecomp.sdc.be.ui.mapper.FilterConstraintMapper;
import org.openecomp.sdc.be.ui.model.UIConstraint;
import org.openecomp.sdc.be.user.Role;
import org.openecomp.sdc.common.log.wrappers.Logger;
final boolean shouldLock, final ComponentTypeEnum componentTypeEnum)
throws BusinessLogicException {
final Component component = getComponent(componentId);
- final Optional<ComponentInstance> componentInstance = getComponentInstance(componentInstanceId, component);
- Optional<CINodeFilterDataDefinition> filterDataDefinition = getCiNodeFilterDataDefinition(componentInstance);
+ Optional<CINodeFilterDataDefinition> filterDataDefinition =
+ component.getComponentInstanceById(componentInstanceId).map(ComponentInstance::getNodeFilter);
if (filterDataDefinition.isPresent()) {
return filterDataDefinition;
}
public Optional<String> deleteNodeFilterIfExists(final String componentId, final String componentInstanceId, final boolean shouldLock,
final ComponentTypeEnum componentTypeEnum) throws BusinessLogicException {
final Component component = getComponent(componentId);
- final Optional<CINodeFilterDataDefinition> nodeFilterDataDefinition = getCiNodeFilterDataDefinition(componentInstanceId, component);
- if (!nodeFilterDataDefinition.isPresent()) {
+ final Optional<CINodeFilterDataDefinition> nodeFilterDataDefinition = getComponentInstanceNodeFilter(componentInstanceId, component);
+ if (nodeFilterDataDefinition.isEmpty()) {
return Optional.ofNullable(componentInstanceId);
}
final Either<String, StorageOperationStatus> result;
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,
+ final FilterConstraintDto filterConstraint, final boolean shouldLock,
final ComponentTypeEnum componentTypeEnum,
- final NodeFilterConstraintType nodeFilterConstraintType, final String capabilityName)
- throws BusinessLogicException {
+ final NodeFilterConstraintType nodeFilterConstraintType,
+ final String capabilityName) throws BusinessLogicException {
final Component component = getComponent(componentId);
- CINodeFilterDataDefinition nodeFilterDataDefinition = validateAndReturnNodeFilterDefinition(componentInstanceId, action, constraint,
- component, nodeFilterConstraintType, capabilityName);
+ validateNodeFilter(component, componentInstanceId, filterConstraint);
+ CINodeFilterDataDefinition nodeFilterDataDefinition = getComponentInstanceNodeFilterOrThrow(componentInstanceId, component);
boolean wasLocked = false;
try {
if (shouldLock) {
lockComponent(component.getUniqueId(), component, "Add Node Filter on Component");
wasLocked = true;
}
- 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);
+ final PropertyFilterDataDefinition filterPropertyDataDefinition = new PropertyFilterDataDefinition();
+ filterPropertyDataDefinition.setName(filterConstraint.getPropertyName());
+ filterPropertyDataDefinition.setConstraints(List.of(new FilterConstraintMapper().mapTo(filterConstraint)));
+ final Either<CINodeFilterDataDefinition, StorageOperationStatus> result = addNodeFilter(componentId, componentInstanceId,
+ nodeFilterConstraintType, nodeFilterDataDefinition, filterPropertyDataDefinition, capabilityName);
if (result.isRight()) {
- janusGraphDao.rollback();
- throw new BusinessLogicException(componentsUtils
- .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(result.right().value()), component.getSystemName()));
+ throw new BusinessLogicException(componentsUtils.getResponseFormatByResource(
+ componentsUtils.convertFromStorageResponse(result.right().value()), component.getSystemName()
+ ));
} else {
nodeFilterDataDefinition = result.left().value();
}
} catch (final Exception e) {
janusGraphDao.rollback();
LOGGER.error(BUSINESS_PROCESS_ERROR, "Exception occurred during add component node filter property values: {}", e.getMessage(), e);
+ if (e instanceof BusinessLogicException) {
+ throw e;
+ }
throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
} finally {
if (wasLocked) {
return Optional.ofNullable(nodeFilterDataDefinition);
}
- public Optional<CINodeFilterDataDefinition> deleteNodeFilter(final String componentId, final String componentInstanceId,
- final NodeFilterConstraintAction action, final String constraint, final int position,
+ public Optional<CINodeFilterDataDefinition> deleteNodeFilter(final String componentId, final String componentInstanceId, final int position,
final boolean shouldLock, final ComponentTypeEnum componentTypeEnum,
final NodeFilterConstraintType nodeFilterConstraintType)
throws BusinessLogicException {
+
final Component component = getComponent(componentId);
- CINodeFilterDataDefinition nodeFilterDataDefinition = validateAndReturnNodeFilterDefinition(componentInstanceId, action, constraint,
- component, nodeFilterConstraintType, "");
+ CINodeFilterDataDefinition nodeFilterDataDefinition = getComponentInstanceNodeFilterOrThrow(componentInstanceId, component);
boolean wasLocked = false;
try {
if (shouldLock) {
return Optional.ofNullable(nodeFilterDataDefinition);
}
- private Either<CINodeFilterDataDefinition, StorageOperationStatus> addNewNodeFilter(final String componentId, final String componentInstanceId,
- final NodeFilterConstraintType nodeFilterConstraintType,
- final CINodeFilterDataDefinition nodeFilterDataDefinition,
- final RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition,
- final String capabilityName) {
+ private Either<CINodeFilterDataDefinition, StorageOperationStatus> addNodeFilter(final String componentId, final String componentInstanceId,
+ final NodeFilterConstraintType nodeFilterConstraintType,
+ final CINodeFilterDataDefinition nodeFilterDataDefinition,
+ final PropertyFilterDataDefinition propertyFilterDataDefinition,
+ final String capabilityName) {
if (NodeFilterConstraintType.PROPERTIES.equals(nodeFilterConstraintType)) {
return nodeFilterOperation
- .addNewProperty(componentId, componentInstanceId, nodeFilterDataDefinition, requirementNodeFilterPropertyDataDefinition);
+ .addPropertyFilter(componentId, componentInstanceId, nodeFilterDataDefinition, propertyFilterDataDefinition);
}
final RequirementNodeFilterCapabilityDataDefinition requirementNodeFilterCapabilityDataDefinition = new RequirementNodeFilterCapabilityDataDefinition();
requirementNodeFilterCapabilityDataDefinition.setName(capabilityName);
- final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> propertyDataDefinitionListDataDefinition = new ListDataDefinition<>();
+ final ListDataDefinition<PropertyFilterDataDefinition> propertyDataDefinitionListDataDefinition = new ListDataDefinition<>();
propertyDataDefinitionListDataDefinition.getListToscaDataDefinition()
- .addAll(Collections.singleton(requirementNodeFilterPropertyDataDefinition));
+ .add(propertyFilterDataDefinition);
requirementNodeFilterCapabilityDataDefinition.setProperties(propertyDataDefinitionListDataDefinition);
return nodeFilterOperation
- .addNewCapabilities(componentId, componentInstanceId, nodeFilterDataDefinition, requirementNodeFilterCapabilityDataDefinition);
+ .addCapabilities(componentId, componentInstanceId, nodeFilterDataDefinition, requirementNodeFilterCapabilityDataDefinition);
}
private void unlockComponent(final String componentUniqueId, final ComponentTypeEnum componentType) {
return component.getComponentInstanceById(componentInstanceId);
}
- private Optional<CINodeFilterDataDefinition> getCiNodeFilterDataDefinition(final Optional<ComponentInstance> componentInstance) {
- if (componentInstance.isPresent()) {
- return Optional.ofNullable(componentInstance.get().getNodeFilter());
- }
- return Optional.empty();
- }
-
- private Optional<CINodeFilterDataDefinition> getCiNodeFilterDataDefinition(final String componentInstanceId, final Component component)
+ private Optional<CINodeFilterDataDefinition> getComponentInstanceNodeFilter(final String componentInstanceId, final Component component)
throws BusinessLogicException {
final Either<Boolean, ResponseFormat> response = nodeFilterValidator.validateComponentInstanceExist(component, componentInstanceId);
if (response.isRight()) {
throw new BusinessLogicException(
componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
}
- final Optional<ComponentInstance> componentInstance = getComponentInstance(componentInstanceId, component);
- if (componentInstance.isPresent()) {
- return Optional.ofNullable(componentInstance.get().getNodeFilter());
- }
- return Optional.empty();
+ return getComponentInstance(componentInstanceId, component).map(ComponentInstance::getNodeFilter);
}
- private CINodeFilterDataDefinition validateAndReturnNodeFilterDefinition(final String componentInstanceId,
- final NodeFilterConstraintAction action, final String constraint,
- final Component component,
- final NodeFilterConstraintType nodeFilterConstraintType,
- final String capabilityName)
- throws BusinessLogicException {
- 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));
- }
- return cINodeFilterDataDefinition.get();
+ private CINodeFilterDataDefinition getComponentInstanceNodeFilterOrThrow(final String componentInstanceId,
+ final Component component) throws BusinessLogicException {
+ return getComponentInstanceNodeFilter(componentInstanceId, component).orElseThrow(
+ () -> 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, final String capabilityName) throws BusinessLogicException {
- final Either<Boolean, ResponseFormat> response = nodeFilterValidator
- .validateFilter(component, componentInstanceId, Collections.singletonList(constraint), action, nodeFilterConstraintType, capabilityName);
+ private void validateNodeFilter(final Component component, final String componentInstanceId,
+ final FilterConstraintDto constraint) throws BusinessLogicException {
+ final Either<Boolean, ResponseFormat> response = nodeFilterValidator.validateFilter(component, componentInstanceId, constraint);
if (response.isRight()) {
- throw new BusinessLogicException(
- componentsUtils.getResponseFormat(ActionStatus.NODE_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
+ throw new BusinessLogicException(response.right().value());
}
}
public Optional<CINodeFilterDataDefinition> updateNodeFilter(final String componentId, final String componentInstanceId,
final UIConstraint uiConstraint, final ComponentTypeEnum componentTypeEnum,
- final NodeFilterConstraintType nodeFilterConstraintType, final int index)
- throws BusinessLogicException {
- final Optional<CINodeFilterDataDefinition> deleteActionResponse = deleteNodeFilter(componentId, componentInstanceId,
- NodeFilterConstraintAction.DELETE, null, index, true, componentTypeEnum, nodeFilterConstraintType);
- if (!deleteActionResponse.isPresent()) {
+ final NodeFilterConstraintType nodeFilterConstraintType,
+ final int index) throws BusinessLogicException {
+ final Optional<CINodeFilterDataDefinition> deleteActionResponse =
+ deleteNodeFilter(componentId, componentInstanceId, index, true, componentTypeEnum, nodeFilterConstraintType);
+ if (deleteActionResponse.isEmpty()) {
throw new BusinessLogicException(
componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR, "Failed to delete node filter capabilities"));
}
- return addNodeFilter(componentId.toLowerCase(), componentInstanceId, NodeFilterConstraintAction.ADD, uiConstraint.getServicePropertyName(),
- new ConstraintConvertor().convert(uiConstraint), true, componentTypeEnum, nodeFilterConstraintType,
- uiConstraint.getCapabilityName());
+ return addNodeFilter(componentId.toLowerCase(), componentInstanceId, new FilterConstraintMapper().mapFrom(uiConstraint), true,
+ componentTypeEnum, nodeFilterConstraintType, uiConstraint.getCapabilityName());
}
public StorageOperationStatus associateNodeFilterToComponentInstance(final String componentId,
}
//associate node filter properties to component instance
- List<RequirementNodeFilterPropertyDataDefinition> properties = ciNodeFilterDataDefinition.getProperties()
+ List<PropertyFilterDataDefinition> 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);
+ .addPropertyFilter(componentId, componentInstanceId, nodeFilter.left().value(), property);
if (nodeFilterProperty.isRight()) {
throw new ComponentException(
componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(nodeFilterProperty.right().value()),
requirementNodeFilterCapabilityDataDefinition.setName(capability.getName());
requirementNodeFilterCapabilityDataDefinition.setProperties(getProperties(capability.getProperties()));
Either<CINodeFilterDataDefinition, StorageOperationStatus> nodeFilterCapability = nodeFilterOperation
- .addNewCapabilities(componentId, componentInstanceId, nodeFilter.left().value(),
+ .addCapabilities(componentId, componentInstanceId, nodeFilter.left().value(),
requirementNodeFilterCapabilityDataDefinition);
if (nodeFilterCapability.isRight()) {
throw new ComponentException(
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);
- });
+ private ListDataDefinition<PropertyFilterDataDefinition> getProperties(ListDataDefinition<PropertyFilterDataDefinition> properties) {
+ ListDataDefinition<PropertyFilterDataDefinition> updatedProperties = new ListDataDefinition<>();
+ properties.getListToscaDataDefinition().forEach(updatedProperties::add);
return updatedProperties;
}
- private RequirementNodeFilterPropertyDataDefinition getRequirementNodeFilterPropertyDataDefinition(
- RequirementNodeFilterPropertyDataDefinition property) {
- RequirementNodeFilterPropertyDataDefinition requirementNodeFilterPropertyDataDefinition = new RequirementNodeFilterPropertyDataDefinition();
- requirementNodeFilterPropertyDataDefinition.setName(property.getName());
- requirementNodeFilterPropertyDataDefinition.setConstraints(getNodeFilterConstraints(property.getName(), property.getConstraints()));
- return requirementNodeFilterPropertyDataDefinition;
- }
}