* SPDX-License-Identifier: Apache-2.0
* ============LICENSE_END=========================================================
*/
-
package org.openecomp.sdc.be.components.impl;
import static org.openecomp.sdc.be.dao.api.ActionStatus.SUBSTITUTION_FILTER_NOT_FOUND;
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.elements.ListDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.ComponentInstance;
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;
public class ComponentSubstitutionFilterBusinessLogic extends BaseBusinessLogic {
private static final Logger LOGGER = Logger.getLogger(ComponentSubstitutionFilterBusinessLogic.class);
-
private final SubstitutionFilterOperation substitutionFilterOperation;
private final NodeFilterValidator nodeFilterValidator;
@Autowired
- public ComponentSubstitutionFilterBusinessLogic(final IElementOperation elementDao,
- final IGroupOperation groupOperation,
+ public ComponentSubstitutionFilterBusinessLogic(final IElementOperation elementDao, final IGroupOperation groupOperation,
final IGroupInstanceOperation groupInstanceOperation,
- final IGroupTypeOperation groupTypeOperation,
- final InterfaceOperation interfaceOperation,
+ final IGroupTypeOperation groupTypeOperation, final InterfaceOperation interfaceOperation,
final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
final ArtifactsOperations artifactToscaOperation,
final SubstitutionFilterOperation substitutionFilterOperation,
final NodeFilterValidator nodeFilterValidator) {
- super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation,
- interfaceLifecycleTypeOperation, artifactToscaOperation);
+ super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
+ artifactToscaOperation);
this.substitutionFilterOperation = substitutionFilterOperation;
this.nodeFilterValidator = nodeFilterValidator;
}
- public Optional<SubstitutionFilterDataDefinition> createSubstitutionFilterIfNotExist(final String componentId,
- final String componentInstanceId,
- final boolean shouldLock,
+ public Optional<SubstitutionFilterDataDefinition> createSubstitutionFilterIfNotExist(final String componentId, final boolean shouldLock,
final ComponentTypeEnum componentTypeEnum)
throws BusinessLogicException {
-
final Component component = getComponent(componentId);
- final Optional<ComponentInstance> componentInstanceOptional =
- getComponentInstance(componentInstanceId, component);
-
- Optional<SubstitutionFilterDataDefinition> substitutionFilterDataDefinition;
- if (componentInstanceOptional.isPresent()) {
- substitutionFilterDataDefinition = getSubstitutionFilterDataDefinition(componentInstanceOptional.get());
- if (substitutionFilterDataDefinition.isPresent()) {
- return substitutionFilterDataDefinition;
- }
+ Optional<SubstitutionFilterDataDefinition> substitutionFilterDataDefinition = Optional.ofNullable(component.getSubstitutionFilter());
+ if (substitutionFilterDataDefinition.isPresent()) {
+ return substitutionFilterDataDefinition;
}
boolean wasLocked = false;
try {
wasLocked = true;
}
final Either<SubstitutionFilterDataDefinition, StorageOperationStatus> result = substitutionFilterOperation
- .createSubstitutionFilter(componentId, componentInstanceId);
+ .createSubstitutionFilter(componentId);
if (result.isRight()) {
janusGraphDao.rollback();
- LOGGER.error(BUSINESS_PROCESS_ERROR,
- "Failed to Create Substitution filter on component with id {}", componentId);
- throw new BusinessLogicException(componentsUtils.getResponseFormatByResource(componentsUtils
- .convertFromStorageResponse(result.right().value()), component.getSystemName()));
+ LOGGER.error(BUSINESS_PROCESS_ERROR, "Failed to Create Substitution filter on component with id {}", componentId);
+ throw new BusinessLogicException(componentsUtils
+ .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(result.right().value()), component.getSystemName()));
}
substitutionFilterDataDefinition = Optional.ofNullable(result.left().value());
- if (componentInstanceOptional.isPresent() && substitutionFilterDataDefinition.isPresent()) {
- componentInstanceOptional.get().setSubstitutionFilter(substitutionFilterDataDefinition.get());
- }
+ component.setSubstitutionFilter(substitutionFilterDataDefinition.get());
janusGraphDao.commit();
LOGGER.debug("Substitution filter successfully created in component {} . ", component.getSystemName());
} catch (final Exception e) {
janusGraphDao.rollback();
- LOGGER.error(BUSINESS_PROCESS_ERROR,
- "Exception occurred during add Component Substitution filter property values: {}", e.getMessage(), e);
+ LOGGER
+ .error(BUSINESS_PROCESS_ERROR, "Exception occurred during add Component Substitution filter property values: {}", e.getMessage(), e);
throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
-
} finally {
if (wasLocked) {
unlockComponent(component.getUniqueId(), componentTypeEnum);
}
}
-
return substitutionFilterDataDefinition;
}
- public Optional<SubstitutionFilterDataDefinition> addSubstitutionFilter(final String componentId,
- final String componentInstanceId,
- final NodeFilterConstraintAction action,
- final String propertyName,
- final String constraint,
- final boolean shouldLock,
- final ComponentTypeEnum componentTypeEnum)
- throws BusinessLogicException {
-
+ public Optional<SubstitutionFilterDataDefinition> addSubstitutionFilter(final String componentId, final String propertyName,
+ final String constraint, final boolean shouldLock,
+ final ComponentTypeEnum componentTypeEnum) throws BusinessLogicException {
final Component component = getComponent(componentId);
- SubstitutionFilterDataDefinition substitutionFilterDataDefinition = validateAndReturnSubstitutionFilterDefinition(
- componentInstanceId,
- action, constraint, component);
+ final Either<Boolean, ResponseFormat> response = nodeFilterValidator
+ .validateComponentFilter(component, Collections.singletonList(constraint), NodeFilterConstraintAction.ADD);
+ if (response.isRight()) {
+ throw new BusinessLogicException(
+ componentsUtils.getResponseFormat(ActionStatus.SUBSTITUTION_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
+ }
boolean wasLocked = false;
try {
if (shouldLock) {
lockComponent(component.getUniqueId(), component, "Add Substitution Filter on Component");
wasLocked = true;
}
- final RequirementSubstitutionFilterPropertyDataDefinition newProperty =
- new RequirementSubstitutionFilterPropertyDataDefinition();
+ final RequirementSubstitutionFilterPropertyDataDefinition newProperty = new RequirementSubstitutionFilterPropertyDataDefinition();
newProperty.setName(propertyName);
newProperty.setConstraints(Collections.singletonList(constraint));
- final Either<SubstitutionFilterDataDefinition, StorageOperationStatus> result = substitutionFilterOperation
- .addNewProperty(componentId, componentInstanceId, substitutionFilterDataDefinition, newProperty);
-
- if (result.isRight()) {
+ final Either<SubstitutionFilterDataDefinition, StorageOperationStatus> resultEither = substitutionFilterOperation
+ .addPropertyFilter(componentId, component.getSubstitutionFilter(), newProperty);
+ if (resultEither.isRight()) {
janusGraphDao.rollback();
- throw new BusinessLogicException(componentsUtils.getResponseFormatByResource(componentsUtils
- .convertFromStorageResponse(result.right().value()), component.getSystemName()));
- } else {
- substitutionFilterDataDefinition = result.left().value();
+ throw new BusinessLogicException(componentsUtils
+ .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(resultEither.right().value()),
+ component.getSystemName()));
}
janusGraphDao.commit();
LOGGER.debug("Substitution filter successfully created in component {} . ", component.getSystemName());
-
+ return Optional.ofNullable(resultEither.left().value());
} catch (final Exception e) {
janusGraphDao.rollback();
- LOGGER.error(BUSINESS_PROCESS_ERROR,
- "Exception occurred during add component substitution filter property values: {}", e.getMessage(), e);
+ LOGGER
+ .error(BUSINESS_PROCESS_ERROR, "Exception occurred during add component substitution filter property values: {}", e.getMessage(), e);
throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
-
} finally {
if (wasLocked) {
unlockComponent(component.getUniqueId(), componentTypeEnum);
}
}
- return Optional.ofNullable(substitutionFilterDataDefinition);
}
- public Optional<SubstitutionFilterDataDefinition> updateSubstitutionFilter(final String componentId,
- final String componentInstanceId,
- final List<String> constraints,
- final boolean shouldLock,
- final ComponentTypeEnum componentTypeEnum)
+ public Optional<SubstitutionFilterDataDefinition> updateSubstitutionFilter(final String componentId, final List<String> constraints,
+ final boolean shouldLock, final ComponentTypeEnum componentTypeEnum)
throws BusinessLogicException {
-
final Component component = getComponent(componentId);
-
final Either<Boolean, ResponseFormat> response = nodeFilterValidator
- .validateFilter(component, componentInstanceId, constraints, NodeFilterConstraintAction.UPDATE);
+ .validateComponentFilter(component, constraints, NodeFilterConstraintAction.UPDATE);
if (response.isRight()) {
- throw new BusinessLogicException(componentsUtils
- .getResponseFormat(SUBSTITUTION_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
+ throw new BusinessLogicException(
+ componentsUtils.getResponseFormat(ActionStatus.SUBSTITUTION_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
}
- final Optional<ComponentInstance> componentInstance = getComponentInstance(componentInstanceId,
- component);
- if (!componentInstance.isPresent()) {
- throw new BusinessLogicException(ResponseFormatManager.getInstance()
- .getResponseFormat(ActionStatus.GENERAL_ERROR));
- }
- SubstitutionFilterDataDefinition substitutionFilterDataDefinition = componentInstance.get()
- .getSubstitutionFilter();
+ SubstitutionFilterDataDefinition substitutionFilterDataDefinition = component.getSubstitutionFilter();
if (substitutionFilterDataDefinition == null) {
throw new BusinessLogicException(componentsUtils.getResponseFormat(SUBSTITUTION_FILTER_NOT_FOUND));
}
final List<RequirementSubstitutionFilterPropertyDataDefinition> properties = constraints.stream()
.map(this::getRequirementSubstitutionFilterPropertyDataDefinition).collect(Collectors.toList());
final Either<SubstitutionFilterDataDefinition, StorageOperationStatus> result = substitutionFilterOperation
- .updateSubstitutionFilter(componentId, componentInstanceId, substitutionFilterDataDefinition, properties);
-
+ .updateProperties(componentId, substitutionFilterDataDefinition, properties);
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 {
substitutionFilterDataDefinition = result.left().value();
}
janusGraphDao.commit();
LOGGER.debug("Substitution filter successfully updated in component {} . ", component.getSystemName());
-
} catch (final Exception e) {
janusGraphDao.rollback();
LOGGER.error(BUSINESS_PROCESS_ERROR, this.getClass().getName(),
"Exception occurred during update component substitution filter property values: {}", e);
throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
-
} finally {
if (wasLocked) {
unlockComponent(component.getUniqueId(), componentTypeEnum);
return Optional.ofNullable(substitutionFilterDataDefinition);
}
- public Optional<SubstitutionFilterDataDefinition> deleteSubstitutionFilter(final String componentId,
- final String componentInstanceId,
- final NodeFilterConstraintAction action,
- final String constraint,
- final int position,
- final boolean shouldLock,
+ public Optional<SubstitutionFilterDataDefinition> deleteSubstitutionFilter(final String componentId, final int position, final boolean shouldLock,
final ComponentTypeEnum componentTypeEnum)
throws BusinessLogicException {
-
final Component component = getComponent(componentId);
- SubstitutionFilterDataDefinition substitutionFilterDataDefinition =
- validateAndReturnSubstitutionFilterDefinition(componentInstanceId, action, constraint, component);
+ SubstitutionFilterDataDefinition substitutionFilterDataDefinition = component.getSubstitutionFilter();
boolean wasLocked = false;
try {
if (shouldLock) {
- lockComponent(component.getUniqueId(), component,"Add Node Filter on Component");
+ lockComponent(component.getUniqueId(), component, "Delete substitution Filter on Component");
wasLocked = true;
}
final Either<SubstitutionFilterDataDefinition, StorageOperationStatus> result = substitutionFilterOperation
- .deleteConstraint(componentId, componentInstanceId, substitutionFilterDataDefinition, position);
+ .deleteConstraint(componentId, substitutionFilterDataDefinition, position);
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 {
substitutionFilterDataDefinition = result.left().value();
}
janusGraphDao.commit();
LOGGER.debug("Substitution filter successfully deleted in component {} . ", component.getSystemName());
-
} catch (final Exception e) {
janusGraphDao.rollback();
- LOGGER.error(BUSINESS_PROCESS_ERROR,
- "Exception occurred during delete component substitution filter property values: {}",
- e.getMessage(), e);
+ LOGGER.error(BUSINESS_PROCESS_ERROR, "Exception occurred during delete component substitution filter property values: {}", e.getMessage(),
+ e);
throw new BusinessLogicException(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
-
} finally {
if (wasLocked) {
unlockComponent(component.getUniqueId(), componentTypeEnum);
return Optional.ofNullable(substitutionFilterDataDefinition);
}
- private Optional<SubstitutionFilterDataDefinition> getSubstitutionFilterDataDefinition(
- final ComponentInstance componentInstance) {
-
- final SubstitutionFilterDataDefinition substitutionFilterDataDefinition =
- componentInstance.getSubstitutionFilter();
- if (componentInstance.getSubstitutionFilter() != null) {
- return Optional.ofNullable(substitutionFilterDataDefinition);
- }
- return Optional.empty();
- }
-
- private void unlockComponent(final String componentUniqueId,
- final ComponentTypeEnum componentType) {
+ private void unlockComponent(final String componentUniqueId, final ComponentTypeEnum componentType) {
graphLockOperation.unlockComponent(componentUniqueId, componentType.getNodeType());
}
return user;
}
- private Optional<ComponentInstance> getComponentInstance(final String componentInstanceId,
- final Component component) {
- return component.getComponentInstanceById(componentInstanceId);
+ private RequirementSubstitutionFilterPropertyDataDefinition getRequirementSubstitutionFilterPropertyDataDefinition(final String constraint) {
+ final RequirementSubstitutionFilterPropertyDataDefinition requirementSubstitutionFilterPropertyDataDefinition = new RequirementSubstitutionFilterPropertyDataDefinition();
+ requirementSubstitutionFilterPropertyDataDefinition.setConstraints(Arrays.asList(constraint));
+ return requirementSubstitutionFilterPropertyDataDefinition;
}
- private Optional<SubstitutionFilterDataDefinition> getComponentInstanceSubstitutionFilterDataDefinition(
- final String componentInstanceId, final Component component)
+ public void addSubstitutionFilterInGraph(String componentId,
+ ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> substitutionFilterProperties)
throws BusinessLogicException {
-
- if (nodeFilterValidator.validateComponentInstanceExist(component, componentInstanceId).isRight()) {
- throw new BusinessLogicException(componentsUtils
- .getResponseFormat(SUBSTITUTION_FILTER_NOT_FOUND));
- }
- return getComponentInstance(componentInstanceId, component).map(ComponentInstance::getSubstitutionFilter);
- }
-
- private SubstitutionFilterDataDefinition validateAndReturnSubstitutionFilterDefinition(
- final String componentInstanceId, final NodeFilterConstraintAction action, final String constraint,
- final Component component) throws BusinessLogicException {
-
- validateSubstitutionFilter(component, componentInstanceId, action, constraint);
- final Optional<SubstitutionFilterDataDefinition> substitutionFilterDataDefinition =
- getComponentInstanceSubstitutionFilterDataDefinition(componentInstanceId, component);
- if (!substitutionFilterDataDefinition.isPresent()) {
- throw new BusinessLogicException(componentsUtils.getResponseFormat(SUBSTITUTION_FILTER_NOT_FOUND));
- }
- return substitutionFilterDataDefinition.get();
- }
-
- private void validateSubstitutionFilter(final Component component,
- final String componentInstanceId,
- final NodeFilterConstraintAction action,
- final String constraint) throws BusinessLogicException {
- final Either<Boolean, ResponseFormat> response = nodeFilterValidator
- .validateFilter(component, componentInstanceId, Collections.singletonList(constraint), action);
- if (response.isRight()) {
- throw new BusinessLogicException(componentsUtils
- .getResponseFormat(SUBSTITUTION_FILTER_NOT_FOUND, response.right().value().getFormattedMessage()));
+ Either<SubstitutionFilterDataDefinition, StorageOperationStatus> updateSubstitutionFilter;
+ Optional<SubstitutionFilterDataDefinition> substitutionFilter = createSubstitutionFilterIfNotExist(componentId, true,
+ ComponentTypeEnum.SERVICE);
+ if (substitutionFilter.isPresent()) {
+ for (RequirementSubstitutionFilterPropertyDataDefinition filter : substitutionFilterProperties.getListToscaDataDefinition()) {
+ updateSubstitutionFilter = substitutionFilterOperation.addPropertyFilter(componentId, substitutionFilter.get(), filter);
+ if (updateSubstitutionFilter.isRight()) {
+ throw new BusinessLogicException(componentsUtils
+ .getResponseFormat(componentsUtils.convertFromStorageResponse(updateSubstitutionFilter.right().value())));
+ }
+ }
}
}
- private RequirementSubstitutionFilterPropertyDataDefinition getRequirementSubstitutionFilterPropertyDataDefinition(
- final String constraint) {
-
- final RequirementSubstitutionFilterPropertyDataDefinition requirementSubstitutionFilterPropertyDataDefinition =
- new RequirementSubstitutionFilterPropertyDataDefinition();
- requirementSubstitutionFilterPropertyDataDefinition.setConstraints(Arrays.asList(constraint));
- return requirementSubstitutionFilterPropertyDataDefinition;
- }
-}
\ No newline at end of file
+}
Code Review / sdc.git / blobdiff