final String constraint,
final int position,
final boolean shouldLock,
- final ComponentTypeEnum componentTypeEnum)
+ final ComponentTypeEnum componentTypeEnum,
+ final NodeFilterConstraintType nodeFilterConstraintType)
throws BusinessLogicException {
final Component component = getComponent(componentId);
wasLocked = true;
}
final Either<CINodeFilterDataDefinition, StorageOperationStatus> result = nodeFilterOperation
- .deleteConstraint(componentId, componentInstanceId, nodeFilterDataDefinition, position);
+ .deleteConstraint(componentId, componentInstanceId, nodeFilterDataDefinition, position,
+ nodeFilterConstraintType);
if (result.isRight()) {
janusGraphDao.rollback();
throw new BusinessLogicException(componentsUtils.getResponseFormatByResource(componentsUtils
componentNodeFilterBusinessLogic.validateUser(userId);
try {
- final Optional<CINodeFilterDataDefinition>actionResponse = componentNodeFilterBusinessLogic
+ final Optional<NodeFilterConstraintType> nodeFilterConstraintType =
+ NodeFilterConstraintType.parse(constraintType);
+ if (!nodeFilterConstraintType.isPresent()) {
+ return buildErrorResponse(getComponentsUtils().getResponseFormat(ActionStatus.INVALID_CONTENT_PARAM,
+ "Invalid value for NodeFilterConstraintType enum %s", constraintType));
+ }
+ final Optional<CINodeFilterDataDefinition> actionResponse = componentNodeFilterBusinessLogic
.deleteNodeFilter(componentId.toLowerCase(), componentInstanceId, NodeFilterConstraintAction.DELETE,
- null, index, true, ComponentTypeEnum.findByParamName(componentType));
+ null, index, true, ComponentTypeEnum.findByParamName(componentType),
+ nodeFilterConstraintType.get());
if (!actionResponse.isPresent()) {
LOGGER.debug(FAILED_TO_DELETE_NODE_FILTER);
.thenReturn(StorageOperationStatus.OK);
when(nodeFilterOperation
- .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0))
+ .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
+ NodeFilterConstraintType.PROPERTIES))
.thenReturn(Either.left(ciNodeFilterDataDefinition));
when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
final Optional<CINodeFilterDataDefinition> deleteNodeFilterResult = componentNodeFilterBusinessLogic
.deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
- 0, true, ComponentTypeEnum.RESOURCE);
+ 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES);
assertThat(deleteNodeFilterResult).isPresent();
.validateFilter(resource, componentInstanceId, singletonList(constraint),
NodeFilterConstraintAction.DELETE);
verify(nodeFilterOperation, times(1))
- .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0);
+ .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
+ NodeFilterConstraintType.PROPERTIES);
verify(graphLockOperation, times(1)).unlockComponent(componentId, NodeTypeEnum.Resource);
}
.thenReturn(StorageOperationStatus.OK);
when(nodeFilterOperation
- .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0))
+ .deleteConstraint(componentId, componentInstanceId, ciNodeFilterDataDefinition, 0,
+ NodeFilterConstraintType.PROPERTIES))
.thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
when(graphLockOperation.unlockComponent(componentId, NodeTypeEnum.Resource))
assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
.deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
- 0, true, ComponentTypeEnum.RESOURCE));
+ 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES));
verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
verify(graphLockOperation, times(1)).lockComponent(componentId, NodeTypeEnum.Resource);
assertThrows(BusinessLogicException.class, () -> componentNodeFilterBusinessLogic
.deleteNodeFilter(componentId, componentInstanceId, NodeFilterConstraintAction.DELETE, constraint,
- 0, true, ComponentTypeEnum.RESOURCE));
+ 0, true, ComponentTypeEnum.RESOURCE, NodeFilterConstraintType.PROPERTIES));
verify(toscaOperationFacade, times(1)).getToscaElement(componentId);
verify(nodeFilterValidator, times(1))
when(componentsUtils.getResponseFormat(ActionStatus.OK)).thenReturn(responseFormat);
when(componentNodeFilterBusinessLogic.deleteNodeFilter(componentId, componentInstance,
- NodeFilterConstraintAction.DELETE, null, 0, true, ComponentTypeEnum.RESOURCE))
+ NodeFilterConstraintAction.DELETE, null, 0, true, ComponentTypeEnum.RESOURCE,
+ NodeFilterConstraintType.PROPERTIES))
.thenReturn(Optional.of(ciNodeFilterDataDefinition));
final Response response = target()
verify(componentNodeFilterBusinessLogic, times(1))
.deleteNodeFilter(anyString(), anyString(), ArgumentMatchers.any(NodeFilterConstraintAction.class),
- nullable(String.class), anyInt(), anyBoolean(), ArgumentMatchers.any(ComponentTypeEnum.class));
+ nullable(String.class), anyInt(), anyBoolean(), ArgumentMatchers.any(ComponentTypeEnum.class),
+ ArgumentMatchers.any(NodeFilterConstraintType.class));
assertThat(response.getStatus()).isEqualTo(HttpStatus.OK_200);
}
import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
+import org.openecomp.sdc.be.datatypes.enums.NodeFilterConstraintType;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
public Either<CINodeFilterDataDefinition, StorageOperationStatus> deleteConstraint(final String serviceId,
final String componentInstanceId,
final CINodeFilterDataDefinition nodeFilterDataDefinition,
- final int propertyIndex) {
- ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties =
+ final int propertyIndex,
+ final NodeFilterConstraintType nodeFilterConstraintType) {
+
+ if (NodeFilterConstraintType.PROPERTIES.equals(nodeFilterConstraintType)) {
+ final ListDataDefinition<RequirementNodeFilterPropertyDataDefinition> properties =
nodeFilterDataDefinition.getProperties();
- properties.getListToscaDataDefinition().remove(propertyIndex);
- nodeFilterDataDefinition.setProperties(properties);
+ properties.getListToscaDataDefinition().remove(propertyIndex);
+ nodeFilterDataDefinition.setProperties(properties);
+ } else if (NodeFilterConstraintType.CAPABILITIES.equals(nodeFilterConstraintType)) {
+ final ListDataDefinition<RequirementNodeFilterCapabilityDataDefinition> capabilities =
+ nodeFilterDataDefinition.getCapabilities();
+ capabilities.getListToscaDataDefinition().remove(propertyIndex);
+ nodeFilterDataDefinition.setCapabilities(capabilities);
+ }
return addOrUpdateNodeFilter(true, serviceId, componentInstanceId, nodeFilterDataDefinition);
}