* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* Modifications copyright (c) 2019 Nokia
* ================================================================================
*/
-
package org.openecomp.sdc.be.components.impl;
+import fj.data.Either;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
+import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections4.ListUtils;
import org.apache.commons.collections4.MapUtils;
-import org.apache.commons.lang.BooleanUtils;
-import org.apache.commons.lang.StringUtils;
-import org.apache.commons.lang.builder.ReflectionToStringBuilder;
+import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
+import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
import org.openecomp.sdc.be.components.property.PropertyDeclarationOrchestrator;
import org.openecomp.sdc.be.components.validation.ComponentValidations;
+import org.openecomp.sdc.be.config.BeEcompErrorManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.utils.MapUtil;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
+import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstInputsMap;
import org.openecomp.sdc.be.model.ComponentInstListInput;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
+import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
import org.openecomp.sdc.be.model.tosca.converters.PropertyValueConverter;
+import org.openecomp.sdc.be.resources.data.EntryData;
+import org.openecomp.sdc.common.log.elements.LoggerSupportability;
+import org.openecomp.sdc.common.log.enums.LoggerSupportabilityActions;
+import org.openecomp.sdc.common.log.enums.StatusCode;
import org.openecomp.sdc.common.log.wrappers.Logger;
import org.openecomp.sdc.exception.ResponseFormat;
import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-import fj.data.Either;
-@Component("inputsBusinessLogic")
+@org.springframework.stereotype.Component("inputsBusinessLogic")
public class InputsBusinessLogic extends BaseBusinessLogic {
private static final String CREATE_INPUT = "CreateInput";
private static final String UPDATE_INPUT = "UpdateInput";
-
private static final Logger log = Logger.getLogger(InputsBusinessLogic.class);
private static final String FAILED_TO_FOUND_COMPONENT_ERROR = "Failed to found component {}, error: {}";
- private static final String GET_PROPERTIES_BY_INPUT = "get Properties by input";
private static final String FAILED_TO_FOUND_INPUT_UNDER_COMPONENT_ERROR = "Failed to found input {} under component {}, error: {}";
private static final String GOING_TO_EXECUTE_ROLLBACK_ON_CREATE_GROUP = "Going to execute rollback on create group.";
private static final String GOING_TO_EXECUTE_COMMIT_ON_CREATE_GROUP = "Going to execute commit on create group.";
-
+ private static final String GOING_TO_EXECUTE_ROLLBACK_ON_UPDATE_INPUT = "Going to execute rollback on update input.";
+ private static final String GOING_TO_EXECUTE_COMMIT_ON_UPDATE_INPUT = "Going to execute commit on update input.";
+ private static final LoggerSupportability loggerSupportability = LoggerSupportability.getLogger(InputsBusinessLogic.class.getName());
private final PropertyDeclarationOrchestrator propertyDeclarationOrchestrator;
private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
private final DataTypeBusinessLogic dataTypeBusinessLogic;
@Autowired
- public InputsBusinessLogic(IElementOperation elementDao,
- IGroupOperation groupOperation,
- IGroupInstanceOperation groupInstanceOperation,
- IGroupTypeOperation groupTypeOperation,
- InterfaceOperation interfaceOperation,
- InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
- PropertyDeclarationOrchestrator propertyDeclarationOrchestrator,
- ComponentInstanceBusinessLogic componentInstanceBusinessLogic, DataTypeBusinessLogic dataTypeBusinessLogic,
- ArtifactsOperations artifactToscaOperation) {
- super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation,
- interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
+ public InputsBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation, IGroupInstanceOperation groupInstanceOperation,
+ IGroupTypeOperation groupTypeOperation, InterfaceOperation interfaceOperation,
+ InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
+ PropertyDeclarationOrchestrator propertyDeclarationOrchestrator,
+ ComponentInstanceBusinessLogic componentInstanceBusinessLogic, DataTypeBusinessLogic dataTypeBusinessLogic,
+ ArtifactsOperations artifactToscaOperation) {
+ super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, interfaceOperation, interfaceLifecycleTypeOperation,
+ artifactToscaOperation);
this.propertyDeclarationOrchestrator = propertyDeclarationOrchestrator;
this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
this.dataTypeBusinessLogic = dataTypeBusinessLogic;
* @return
*/
public Either<List<InputDefinition>, ResponseFormat> getInputs(String userId, String componentId) {
-
- validateUserExists(userId, "get Inputs", false);
-
+ validateUserExists(userId);
ComponentParametersView filters = new ComponentParametersView();
filters.disableAll();
filters.setIgnoreInputs(false);
-
- Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getComponentEither = toscaOperationFacade.getToscaElement(componentId, filters);
- if(getComponentEither.isRight()){
+ Either<Component, StorageOperationStatus> getComponentEither = toscaOperationFacade
+ .getToscaElement(componentId, filters);
+ if (getComponentEither.isRight()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_COMPONENT_ERROR, componentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
-
}
- org.openecomp.sdc.be.model.Component component = getComponentEither.left().value();
+ Component component = getComponentEither.left().value();
List<InputDefinition> inputs = component.getInputs();
-
return Either.left(inputs);
-
}
- public Either<List<ComponentInstanceInput>, ResponseFormat> getComponentInstanceInputs(String userId, String componentId, String componentInstanceId) {
-
- validateUserExists(userId, "get Inputs", false);
+ public Either<List<ComponentInstanceInput>, ResponseFormat> getComponentInstanceInputs(String userId, String componentId,
+ String componentInstanceId) {
+ validateUserExists(userId);
ComponentParametersView filters = new ComponentParametersView();
filters.disableAll();
filters.setIgnoreInputs(false);
filters.setIgnoreComponentInstances(false);
filters.setIgnoreComponentInstancesInputs(false);
-
- Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getComponentEither = toscaOperationFacade.getToscaElement(componentId, filters);
- if(getComponentEither.isRight()){
+ Either<Component, StorageOperationStatus> getComponentEither = toscaOperationFacade
+ .getToscaElement(componentId, filters);
+ if (getComponentEither.isRight()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_COMPONENT_ERROR, componentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
-
}
- org.openecomp.sdc.be.model.Component component = getComponentEither.left().value();
-
- if(!ComponentValidations.validateComponentInstanceExist(component, componentInstanceId)){
+ Component component = getComponentEither.left().value();
+ if (!ComponentValidations.validateComponentInstanceExist(component, componentInstanceId)) {
ActionStatus actionStatus = ActionStatus.COMPONENT_INSTANCE_NOT_FOUND;
log.debug("Failed to found component instance inputs {}, error: {}", componentInstanceId, actionStatus);
+ loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS, component.getComponentMetadataForSupportLog(), StatusCode.ERROR,
+ "Failed to found component instance inputs componentInstanceId: {}", componentInstanceId);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
}
- Map<String, List<ComponentInstanceInput>> ciInputs =
- Optional.ofNullable(component.getComponentInstancesInputs()).orElse(Collections.emptyMap());
-
- // Set Constraints on Input
- MapUtils.emptyIfNull(ciInputs).values()
- .forEach(inputs -> ListUtils.emptyIfNull(inputs)
- .forEach(input -> input.setConstraints(setInputConstraint(input))));
+ Map<String, List<ComponentInstanceInput>> ciInputs = Optional.ofNullable(component.getComponentInstancesInputs())
+ .orElse(Collections.emptyMap());
+ // Set Constraints on Input
+ MapUtils.emptyIfNull(ciInputs).values()
+ .forEach(inputs -> ListUtils.emptyIfNull(inputs).forEach(input -> input.setConstraints(setInputConstraint(input))));
return Either.left(ciInputs.getOrDefault(componentInstanceId, Collections.emptyList()));
}
* @param inputId
* @return
*/
-
- public Either<List<ComponentInstanceProperty>, ResponseFormat> getComponentInstancePropertiesByInputId(String userId, String componentId, String instanceId, String inputId) {
- validateUserExists(userId, GET_PROPERTIES_BY_INPUT, false);
+ public Either<List<ComponentInstanceProperty>, ResponseFormat> getComponentInstancePropertiesByInputId(String userId, String componentId,
+ String instanceId, String inputId) {
+ validateUserExists(userId);
String parentId = componentId;
- org.openecomp.sdc.be.model.Component component;
+ Component component;
ComponentParametersView filters = new ComponentParametersView();
filters.disableAll();
filters.setIgnoreComponentInstances(false);
-
- if(!instanceId.equals(inputId)){
-
-
- Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getComponentEither = toscaOperationFacade.getToscaElement(parentId, filters);
-
- if(getComponentEither.isRight()){
+ if (!instanceId.equals(inputId)) {
+ Either<Component, StorageOperationStatus> getComponentEither = toscaOperationFacade
+ .getToscaElement(parentId, filters);
+ if (getComponentEither.isRight()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_COMPONENT_ERROR, parentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
-
}
component = getComponentEither.left().value();
- Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci ->ci.getUniqueId().equals(instanceId)).findAny();
- if(ciOp.isPresent()){
+ Optional<ComponentInstance> ciOp = component.getComponentInstances().stream().filter(ci -> ci.getUniqueId().equals(instanceId)).findAny();
+ if (ciOp.isPresent()) {
parentId = ciOp.get().getComponentUid();
}
-
}
-
filters.setIgnoreInputs(false);
-
filters.setIgnoreComponentInstancesProperties(false);
filters.setIgnoreComponentInstancesInputs(false);
filters.setIgnoreProperties(false);
-
- Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getComponentEither = toscaOperationFacade.getToscaElement(parentId, filters);
-
- if(getComponentEither.isRight()){
+ Either<Component, StorageOperationStatus> getComponentEither = toscaOperationFacade
+ .getToscaElement(parentId, filters);
+ if (getComponentEither.isRight()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_COMPONENT_ERROR, parentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
-
}
component = getComponentEither.left().value();
-
Optional<InputDefinition> op = component.getInputs().stream().filter(in -> in.getUniqueId().equals(inputId)).findFirst();
- if(!op.isPresent()){
+ if (op.isEmpty()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_INPUT_UNDER_COMPONENT_ERROR, inputId, parentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
}
-
return Either.left(componentInstanceBusinessLogic.getComponentInstancePropertiesByInputId(component, inputId));
-
}
- private Either<String,ResponseFormat> updateInputObjectValue(InputDefinition currentInput, InputDefinition newInput, Map<String, DataTypeDefinition> dataTypes) {
+ private String updateInputObjectValue(InputDefinition currentInput, InputDefinition newInput, Map<String, DataTypeDefinition> dataTypes) {
String innerType = null;
String propertyType = currentInput.getType();
ToscaPropertyType type = ToscaPropertyType.isValidType(propertyType);
log.debug("The type of the property {} is {}", currentInput.getUniqueId(), propertyType);
-
if (type == ToscaPropertyType.LIST || type == ToscaPropertyType.MAP) {
SchemaDefinition def = currentInput.getSchema();
if (def == null) {
log.debug("Schema doesn't exists for property of type {}", type);
- return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
+ throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE));
}
PropertyDataDefinition propDef = def.getProperty();
if (propDef == null) {
log.debug("Property in Schema Definition inside property of type {} doesn't exist", type);
- return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE)));
+ throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE));
}
innerType = propDef.getType();
}
// Specific Update Logic
-
- Either<Object, Boolean> isValid = propertyOperation.validateAndUpdatePropertyValue(propertyType, newInput.getDefaultValue(), true, innerType, dataTypes);
-
- String newValue = currentInput.getDefaultValue();
+ Either<Object, Boolean> isValid = propertyOperation
+ .validateAndUpdatePropertyValue(propertyType, newInput.getDefaultValue(), true, innerType, dataTypes);
+ String newValue = newInput.getDefaultValue();
if (isValid.isRight()) {
Boolean res = isValid.right().value();
if (Boolean.FALSE.equals(res)) {
- return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(DaoStatusConverter.convertJanusGraphStatusToStorageStatus(
- JanusGraphOperationStatus.ILLEGAL_ARGUMENT))));
+ throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
+ DaoStatusConverter.convertJanusGraphStatusToStorageStatus(JanusGraphOperationStatus.ILLEGAL_ARGUMENT)));
}
} else {
Object object = isValid.left().value();
newValue = object.toString();
}
}
- return Either.left(newValue);
+ return newValue;
}
private InputDefinition getInputFromInputsListById(List<InputDefinition> componentsOldInputs, InputDefinition input) {
return componentsOldInputs.stream().filter(in -> in.getUniqueId().equals(input.getUniqueId())).findFirst().orElse(null);
}
- public Either<List<InputDefinition>, ResponseFormat> updateInputsValue(ComponentTypeEnum componentType, String componentId, List<InputDefinition> inputs, String userId, boolean shouldLockComp, boolean inTransaction) {
-
+ public Either<List<InputDefinition>, ResponseFormat> updateInputsValue(ComponentTypeEnum componentType, String componentId,
+ List<InputDefinition> inputs, String userId, boolean shouldLockComp) {
List<InputDefinition> returnInputs = new ArrayList<>();
Either<List<InputDefinition>, ResponseFormat> result = null;
- org.openecomp.sdc.be.model.Component component = null;
-
+ Component component = null;
try {
- validateUserExists(userId, "get input", false);
-
+ validateUserExists(userId);
ComponentParametersView componentParametersView = new ComponentParametersView();
componentParametersView.disableAll();
componentParametersView.setIgnoreInputs(false);
componentParametersView.setIgnoreUsers(false);
- componentParametersView.setIgnoreProperties(false);
- componentParametersView.setIgnoreComponentInstancesProperties(false);
- componentParametersView.setIgnoreComponentInstances(false);
-
- Either<? extends org.openecomp.sdc.be.model.Component, ResponseFormat> validateComponent = validateComponentExists(componentId, componentType, componentParametersView);
-
- if (validateComponent.isRight()) {
- result = Either.right(validateComponent.right().value());
- return result;
- }
- component = validateComponent.left().value();
-
+ componentParametersView.setIgnoreProperties(false);
+ componentParametersView.setIgnoreComponentInstancesProperties(false);
+ componentParametersView.setIgnoreComponentInstances(false);
+ component = validateComponentExists(componentId, componentType, componentParametersView);
if (shouldLockComp) {
- Either<Boolean, ResponseFormat> lockComponent = lockComponent(component, UPDATE_INPUT);
- if (lockComponent.isRight()) {
- result = Either.right(lockComponent.right().value());
+ try {
+ lockComponent(component, UPDATE_INPUT);
+ } catch (ComponentException e) {
+ log.error("Failed to lock component", e);
+ result = Either.right(e.getResponseFormat());
return result;
}
}
-
- Either<Boolean, ResponseFormat> canWork = validateCanWorkOnComponent(component, userId);
- if (canWork.isRight()) {
- result = Either.right(canWork.right().value());
- return result;
- }
-
- //Validate value and Constraint of input
- Either<Boolean, ResponseFormat> constraintValidatorResponse = validateInputValueConstraint(inputs);
- if (constraintValidatorResponse.isRight()) {
- log.error("Failed validation value and constraint of property: {}",
- constraintValidatorResponse.right().value());
- return Either.right(constraintValidatorResponse.right().value());
- }
-
- Either<Map<String, DataTypeDefinition>, ResponseFormat> allDataTypes = getAllDataTypes(applicationDataTypeCache);
- if (allDataTypes.isRight()) {
- result = Either.right(allDataTypes.right().value());
- return result;
+ //Validate value and Constraint of input
+ Either<Boolean, ResponseFormat> constraintValidatorResponse = validateInputValueConstraint(inputs, component.getModel());
+ if (constraintValidatorResponse.isRight()) {
+ log.error("Failed validation value and constraint of property: {}", constraintValidatorResponse.right().value());
+ return Either.right(constraintValidatorResponse.right().value());
}
-
- Map<String, DataTypeDefinition> dataTypes = allDataTypes.left().value();
+ validateCanWorkOnComponent(component, userId);
+ Map<String, DataTypeDefinition> dataTypes;
+ dataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, component.getModel());
List<InputDefinition> componentsOldInputs = Optional.ofNullable(component.getInputs()).orElse(Collections.emptyList());
- for (InputDefinition newInput: inputs) {
+ for (InputDefinition newInput : inputs) {
InputDefinition currInput = getInputFromInputsListById(componentsOldInputs, newInput);
if (currInput == null) {
ActionStatus actionStatus = ActionStatus.COMPONENT_NOT_FOUND;
result = Either.right(componentsUtils.getResponseFormat(actionStatus));
return result;
}
- Either<String, ResponseFormat> updateInputObjectValue = updateInputObjectValue(currInput, newInput, dataTypes);
- if ( updateInputObjectValue.isRight()) {
- return Either.right(updateInputObjectValue.right().value());
- }
- String newValue = updateInputObjectValue.left().value();
- currInput.setValue(newValue);
- currInput.setDefaultValue(newValue);
+ String updateInputObjectValue = updateInputObjectValue(currInput, newInput, dataTypes);
+ currInput.setDefaultValue(updateInputObjectValue);
currInput.setOwnerId(userId);
+ currInput.setMetadata(newInput.getMetadata());
+ if (newInput.isRequired() != null) {
+ currInput.setRequired(newInput.isRequired());
+ }
Either<InputDefinition, StorageOperationStatus> status = toscaOperationFacade.updateInputOfComponent(component, currInput);
- if(status.isRight()){
+ if (status.isRight()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponseForResourceInstanceProperty(status.right().value());
result = Either.right(componentsUtils.getResponseFormat(actionStatus, ""));
return result;
}
}
result = Either.left(returnInputs);
- return result;
- } finally {
- if (!inTransaction) {
- if (result == null || result.isRight()) {
- log.debug(GOING_TO_EXECUTE_ROLLBACK_ON_CREATE_GROUP);
- janusGraphDao.rollback();
- } else {
- log.debug(GOING_TO_EXECUTE_COMMIT_ON_CREATE_GROUP);
- janusGraphDao.commit();
- }
- }
- // unlock resource
- if (shouldLockComp && component != null) {
- graphLockOperation.unlockComponent(componentId, componentType.getNodeType());
- }
- }
+ } catch (ComponentException e) {
+ log.debug(GOING_TO_EXECUTE_ROLLBACK_ON_UPDATE_INPUT);
+ unlockRollbackWithException(component, e);
+ } catch (Exception e) {
+ log.debug(GOING_TO_EXECUTE_ROLLBACK_ON_UPDATE_INPUT);
+ unlockRollbackWithException(component, new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR));
+ }
+ log.debug(GOING_TO_EXECUTE_COMMIT_ON_UPDATE_INPUT);
+ unlockWithCommit(component);
+ return result;
}
- private Either<Boolean, ResponseFormat> validateInputValueConstraint(List<InputDefinition> inputs) {
- PropertyValueConstraintValidationUtil propertyValueConstraintValidationUtil =
- PropertyValueConstraintValidationUtil.getInstance();
- List<InputDefinition> inputDefinitions = new ArrayList<>();
- for (InputDefinition inputDefinition : inputs) {
- InputDefinition inputDef = new InputDefinition();
- inputDefinition.setDefaultValue(inputDefinition.getDefaultValue());
- inputDefinition.setInputPath(inputDefinition.getSubPropertyInputPath());
- inputDefinition.setType(inputDefinition.getType());
- if (Objects.nonNull(inputDefinition.getParentPropertyType())) {
- ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
- propertyDefinition.setType(inputDefinition.getParentPropertyType());
-
- inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
- }
-
- inputDefinitions.add(inputDef);
- }
-
- return propertyValueConstraintValidationUtil.validatePropertyConstraints(inputDefinitions, applicationDataTypeCache);
- }
+ private Either<Boolean, ResponseFormat> validateInputValueConstraint(List<InputDefinition> inputs, final String model) {
+ PropertyValueConstraintValidationUtil propertyValueConstraintValidationUtil = new PropertyValueConstraintValidationUtil();
+ List<InputDefinition> inputDefinitions = new ArrayList<>();
+ for (InputDefinition inputDefinition : inputs) {
+ InputDefinition inputDef = new InputDefinition();
+ inputDefinition.setDefaultValue(inputDefinition.getDefaultValue());
+ inputDefinition.setInputPath(inputDefinition.getSubPropertyInputPath());
+ inputDefinition.setType(inputDefinition.getType());
+ if (Objects.nonNull(inputDefinition.getParentPropertyType())) {
+ ComponentInstanceProperty propertyDefinition = new ComponentInstanceProperty();
+ propertyDefinition.setType(inputDefinition.getParentPropertyType());
+ inputDefinition.setProperties(Collections.singletonList(propertyDefinition));
+ }
+ inputDefinitions.add(inputDef);
+ }
+ return propertyValueConstraintValidationUtil.validatePropertyConstraints(inputDefinitions, applicationDataTypeCache, model);
+ }
public Either<List<ComponentInstanceInput>, ResponseFormat> getInputsForComponentInput(String userId, String componentId, String inputId) {
- validateUserExists(userId, GET_PROPERTIES_BY_INPUT, false);
- org.openecomp.sdc.be.model.Component component = null;
+ validateUserExists(userId);
+ Component component = null;
ComponentParametersView filters = new ComponentParametersView();
filters.disableAll();
filters.setIgnoreComponentInstances(false);
filters.setIgnoreInputs(false);
filters.setIgnoreComponentInstancesInputs(false);
filters.setIgnoreProperties(false);
-
- Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getComponentEither = toscaOperationFacade.getToscaElement(componentId, filters);
-
- if(getComponentEither.isRight()){
+ Either<Component, StorageOperationStatus> getComponentEither = toscaOperationFacade
+ .getToscaElement(componentId, filters);
+ if (getComponentEither.isRight()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_COMPONENT_ERROR, componentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
-
}
component = getComponentEither.left().value();
-
Optional<InputDefinition> op = component.getInputs().stream().filter(in -> in.getUniqueId().equals(inputId)).findFirst();
- if(!op.isPresent()){
+ if (op.isEmpty()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_INPUT_UNDER_COMPONENT_ERROR, inputId, componentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
}
-
return Either.left(componentInstanceBusinessLogic.getComponentInstanceInputsByInputId(component, inputId));
-
}
@Override
- public Either<List<InputDefinition>, ResponseFormat> declareProperties(String userId, String componentId,
- ComponentTypeEnum componentTypeEnum, ComponentInstInputsMap componentInstInputsMap) {
-
+ public Either<List<InputDefinition>, ResponseFormat> declareProperties(String userId, String componentId, ComponentTypeEnum componentTypeEnum,
+ ComponentInstInputsMap componentInstInputsMap) {
return createMultipleInputs(userId, componentId, componentTypeEnum, componentInstInputsMap, true, false);
}
- public Either<List<InputDefinition>, ResponseFormat> createMultipleInputs(String userId, String componentId, ComponentTypeEnum componentType, ComponentInstInputsMap componentInstInputsMapUi, boolean shouldLockComp, boolean inTransaction) {
-
+ private Either<List<InputDefinition>, ResponseFormat> createMultipleInputs(String userId, String componentId, ComponentTypeEnum componentType,
+ ComponentInstInputsMap componentInstInputsMapUi,
+ boolean shouldLockComp,
+ boolean inTransaction) {
Either<List<InputDefinition>, ResponseFormat> result = null;
- org.openecomp.sdc.be.model.Component component = null;
-
+ Component component = null;
try {
- validateUserExists(userId, GET_PROPERTIES_BY_INPUT, false);
-
+ validateUserExists(userId);
component = getAndValidateComponentForCreate(userId, componentId, componentType, shouldLockComp);
-
- result = propertyDeclarationOrchestrator.declarePropertiesToInputs(component, componentInstInputsMapUi)
- .left()
- .bind(inputsToCreate -> prepareInputsForCreation(userId, componentId, inputsToCreate))
- .right()
- .map(componentsUtils::getResponseFormat);
-
+ result = propertyDeclarationOrchestrator.declarePropertiesToInputs(component, componentInstInputsMapUi).left()
+ .bind(inputsToCreate -> prepareInputsForCreation(userId, componentId, inputsToCreate)).right()
+ .map(componentsUtils::getResponseFormat);
return result;
-
} catch (ByResponseFormatComponentException e) {
log.error("#createMultipleInputs: Exception thrown: ", e);
result = Either.right(e.getResponseFormat());
return result;
} finally {
-
if (!inTransaction) {
if (result == null || result.isRight()) {
log.debug(GOING_TO_EXECUTE_ROLLBACK_ON_CREATE_GROUP);
if (shouldLockComp && component != null) {
graphLockOperation.unlockComponent(componentId, componentType.getNodeType());
}
-
}
}
/**
* Creates a list input with a data type which has properties specified.
*
- * @param userId User ID
- * @param componentId Component ID
- * @param componentType Component type
+ * @param userId User ID
+ * @param componentId Component ID
+ * @param componentType Component type
* @param componentListInput Properties to be declared and input to be created
- * @param shouldLockComp true if the component should be locked
- * @param inTransaction true if already in transaction
+ * @param shouldLockComp true if the component should be locked
+ * @param inTransaction true if already in transaction
*/
- public Either<List<InputDefinition>, ResponseFormat> createListInput(String userId, String componentId,
- ComponentTypeEnum componentType, ComponentInstListInput componentListInput, boolean shouldLockComp,
- boolean inTransaction) {
-
+ public Either<List<InputDefinition>, ResponseFormat> createListInput(String userId, String componentId, ComponentTypeEnum componentType,
+ ComponentInstListInput componentListInput, boolean shouldLockComp,
+ boolean inTransaction) {
Either<List<InputDefinition>, ResponseFormat> result = null;
- org.openecomp.sdc.be.model.Component component = null;
-
+ Component component = null;
log.trace("#createListInput: enter");
-
try {
/* check if user exists */
- validateUserExists(userId, GET_PROPERTIES_BY_INPUT, false);
+ validateUserExists(userId);
component = getAndValidateComponentForCreate(userId, componentId, componentType, shouldLockComp);
return componentParametersView;
}
- private org.openecomp.sdc.be.model.Component getAndValidateComponentForCreate(
+ private Component getAndValidateComponentForCreate(
String userId, String componentId, ComponentTypeEnum componentType, boolean shouldLockComp
) {
-
ComponentParametersView componentParametersView = getBaseComponentParametersView();
-
- Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither =
- // get Component Object
- validateComponentExists(componentId, componentType, componentParametersView)
- .left().bind(component -> {
- if (shouldLockComp) {
- // lock the component
- return lockComponent(component, CREATE_INPUT).left().map(result -> component);
- }
- return Either.left(component);
- }).left().bind(component -> validateCanWorkOnComponent(component, userId).left().map(result -> component));
- if (componentEither.isRight()) {
- throw new ByResponseFormatComponentException(componentEither.right().value());
+ Component component = validateComponentExists(componentId, componentType, componentParametersView);
+ if (shouldLockComp) {
+ // lock the component
+ lockComponent(component, CREATE_INPUT);
}
- return componentEither.left().value();
+ validateCanWorkOnComponent(component, userId);
+ return component;
}
private DataTypeDefinition prepareDataTypeForListInput(ComponentInstInputsMap inputsMap, InputDefinition input) {
DataTypeDefinition dataType = new DataTypeDefinition();
List<ComponentInstancePropInput> propInputs = inputsMap.resolvePropertiesToDeclare().getRight();
dataType.setName(desiredTypeName);
- dataType.setDerivedFromName(ToscaPropertyType.Root.getType());
+ dataType.setDerivedFromName(ToscaPropertyType.ROOT.getType());
// Copy properties from inputsMap
dataType.setProperties(propInputs.stream().map(PropertyDefinition::new).collect(Collectors.toList()));
return dataType;
}
- private Either<List<InputDefinition>, StorageOperationStatus> prepareInputsForCreation(String userId, String cmptId, List<InputDefinition> inputsToCreate) {
+ private Either<List<InputDefinition>, StorageOperationStatus> prepareInputsForCreation(String userId, String cmptId,
+ List<InputDefinition> inputsToCreate) {
Map<String, InputDefinition> inputsToPersist = MapUtil.toMap(inputsToCreate, InputDefinition::getName);
assignOwnerIdToInputs(userId, inputsToPersist);
- inputsToPersist.values()
- .forEach(input -> input.setConstraints(componentInstanceBusinessLogic.setInputConstraint(input)));
+ inputsToPersist.values()
+ .forEach(input -> input.setConstraints(componentInstanceBusinessLogic.setInputConstraint(input)));
return toscaOperationFacade.addInputsToComponent(inputsToPersist, cmptId)
- .left()
- .map(persistedInputs -> inputsToCreate);
+ .left()
+ .map(persistedInputs -> inputsToCreate);
}
private void assignOwnerIdToInputs(String userId, Map<String, InputDefinition> inputsToCreate) {
inputsToCreate.values().forEach(inputDefinition -> inputDefinition.setOwnerId(userId));
}
- public Either<List<InputDefinition>, ResponseFormat> createInputsInGraph(Map<String, InputDefinition> inputs, org.openecomp.sdc.be.model.Component component) {
+ public Either<List<InputDefinition>, ResponseFormat> createInputsInGraph(Map<String, InputDefinition> inputs,
+ Component component) {
List<InputDefinition> resourceProperties = component.getInputs();
- Either<Map<String, DataTypeDefinition>, ResponseFormat> allDataTypes = getAllDataTypes(applicationDataTypeCache);
- if (allDataTypes.isRight()) {
- return Either.right(allDataTypes.right().value());
- }
- Map<String, DataTypeDefinition> dataTypes = allDataTypes.left().value();
+ final Map<String, DataTypeDefinition> dataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, component.getModel());
for (Map.Entry<String, InputDefinition> inputDefinition : inputs.entrySet()) {
String inputName = inputDefinition.getKey();
inputDefinition.getValue().setName(inputName);
Either<InputDefinition, ResponseFormat> preparedInputEither = prepareAndValidateInputBeforeCreate(inputDefinition.getValue(), dataTypes);
- if(preparedInputEither.isRight()){
+ if (preparedInputEither.isRight()) {
return Either.right(preparedInputEither.right().value());
}
}
if (resourceProperties != null) {
- Map<String, InputDefinition> generatedInputs = resourceProperties.stream().collect(Collectors.toMap(PropertyDataDefinition::getName, i -> i));
+ Map<String, InputDefinition> generatedInputs = resourceProperties.stream()
+ .collect(Collectors.toMap(PropertyDataDefinition::getName, i -> i));
Either<Map<String, InputDefinition>, String> mergeEither = ToscaDataDefinition.mergeDataMaps(generatedInputs, inputs);
- if(mergeEither.isRight()){
+ if (mergeEither.isRight()) {
return Either.right(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_ALREADY_EXIST, mergeEither.right().value()));
}
inputs = mergeEither.left().value();
}
- Either<List<InputDefinition>, StorageOperationStatus> associateInputsEither = toscaOperationFacade.createAndAssociateInputs(inputs, component.getUniqueId());
- if(associateInputsEither.isRight()){
+ Either<List<InputDefinition>, StorageOperationStatus> associateInputsEither = toscaOperationFacade
+ .createAndAssociateInputs(inputs, component.getUniqueId());
+ if (associateInputsEither.isRight()) {
log.debug("Failed to create inputs under component {}. Status is {}", component.getUniqueId(), associateInputsEither.right().value());
+
return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(associateInputsEither.right().value())));
}
return Either.left(associateInputsEither.left().value());
}
private Either<List<InputDefinition>, ResponseFormat> createListInputsInGraph(Map<String, InputDefinition> inputs,
- Map<String, DataTypeDefinition> privateDataTypes, org.openecomp.sdc.be.model.Component component) {
+ Map<String, DataTypeDefinition> privateDataTypes,
+ Component component) {
log.trace("#createListInputsInGraph: enter");
- Either<Map<String, DataTypeDefinition>, ResponseFormat> allDataTypes = getAllDataTypes(
- applicationDataTypeCache);
- if (allDataTypes.isRight()) {
- return Either.right(allDataTypes.right().value());
- }
- Map<String, DataTypeDefinition> dataTypes = allDataTypes.left().value();
+ Map<String, DataTypeDefinition> dataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, component.getModel());
dataTypes.putAll(privateDataTypes);
for (Map.Entry<String, InputDefinition> inputDefinition : inputs.entrySet()) {
* @param inputId
* @return
*/
- public Either<InputDefinition, ResponseFormat> deleteInput(String componentId, String userId, String inputId) {
-
+ public InputDefinition deleteInput(String componentId, String userId, String inputId) {
Either<InputDefinition, ResponseFormat> deleteEither = null;
if (log.isDebugEnabled()) {
log.debug("Going to delete input id: {}", inputId);
}
-
- validateUserExists(userId, "Delete input", true);
-
+ validateUserExists(userId);
ComponentParametersView componentParametersView = getBaseComponentParametersView();
componentParametersView.setIgnoreInterfaces(false);
componentParametersView.setIgnoreDataType(false);
componentParametersView.setIgnoreProperties(false);
-
- Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> componentEither =
- toscaOperationFacade.getToscaElement(componentId, componentParametersView);
+ Either<Component, StorageOperationStatus> componentEither = toscaOperationFacade
+ .getToscaElement(componentId, componentParametersView);
if (componentEither.isRight()) {
- deleteEither = Either.right(componentsUtils.getResponseFormat(
- componentsUtils.convertFromStorageResponse(componentEither.right().value())));
- return deleteEither;
+ throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(componentEither.right().value()));
}
- org.openecomp.sdc.be.model.Component component = componentEither.left().value();
-
+ Component component = componentEither.left().value();
// Validate inputId is child of the component
Optional<InputDefinition> optionalInput = component.getInputs().stream().
- // filter by ID
- filter(input -> input.getUniqueId().equals(inputId)).
- // Get the input
- findAny();
- if (!optionalInput.isPresent()) {
- return Either.right(
- componentsUtils.getResponseFormat(ActionStatus.INPUT_IS_NOT_CHILD_OF_COMPONENT, inputId, componentId));
+ // filter by ID
+ filter(input -> input.getUniqueId().equals(inputId)).
+ // Get the input
+ findAny();
+ if (optionalInput.isEmpty()) {
+ throw new ByActionStatusComponentException(ActionStatus.INPUT_IS_NOT_CHILD_OF_COMPONENT, inputId, componentId);
}
-
InputDefinition inputForDelete = optionalInput.get();
-
// Lock component
- Either<Boolean, ResponseFormat> lockResultEither =
- lockComponent(componentId, component, "deleteInput");
- if (lockResultEither.isRight()) {
- ResponseFormat responseFormat = lockResultEither.right().value();
- deleteEither = Either.right(responseFormat);
- return deleteEither;
- }
-
+ lockComponent(componentId, component, "deleteInput");
// Delete input operations
+ boolean failed = false;
try {
- StorageOperationStatus status =
- toscaOperationFacade.deleteInputOfResource(component, inputForDelete.getName());
+ StorageOperationStatus status = toscaOperationFacade.deleteInputOfResource(component, inputForDelete.getName());
if (status != StorageOperationStatus.OK) {
log.debug("Component id: {} delete input id: {} failed", componentId, inputId);
- deleteEither = Either.right(componentsUtils.getResponseFormat(
- componentsUtils.convertFromStorageResponse(status), component.getName()));
- return deleteEither;
+ throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(status), component.getName());
}
-
- if (BooleanUtils.isTrue(inputForDelete.getIsDeclaredListInput())){
+ if (BooleanUtils.isTrue(inputForDelete.getIsDeclaredListInput())) {
deleteEither = deleteListInput(componentId, inputId, component, inputForDelete, status);
- return deleteEither;
+ if (deleteEither.isRight()) {
+ throw new ByResponseFormatComponentException(deleteEither.right().value());
+ }
+ return deleteEither.left().value();
}
-
- StorageOperationStatus storageOperationStatus =
- propertyDeclarationOrchestrator.unDeclarePropertiesAsInputs(component, inputForDelete);
+ StorageOperationStatus storageOperationStatus = propertyDeclarationOrchestrator.unDeclarePropertiesAsInputs(component, inputForDelete);
if (storageOperationStatus != StorageOperationStatus.OK) {
log.debug("Component id: {} update properties declared as input for input id: {} failed", componentId, inputId);
- deleteEither = Either.right(componentsUtils.getResponseFormat(
- componentsUtils.convertFromStorageResponse(status), component.getName()));
- return deleteEither;
+ throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageOperationStatus), component.getName());
}
-
- deleteEither = Either.left(inputForDelete);
- return deleteEither;
+ return inputForDelete;
+ } catch (ComponentException e) {
+ failed = true;
+ throw e;
} finally {
- if (deleteEither == null || deleteEither.isRight()) {
- log.debug("Component id: {} delete input id: {} failed", componentId, inputId);
- janusGraphDao.rollback();
- } else {
- log.debug("Component id: {} delete input id: {} success", componentId, inputId);
- janusGraphDao.commit();
- }
- unlockComponent(deleteEither, component);
+ unlockComponent(failed, component);
}
}
private Either<InputDefinition, ResponseFormat> deleteListInput(String componentId, String inputId,
- org.openecomp.sdc.be.model.Component component,
- InputDefinition inputForDelete, StorageOperationStatus status) {
+ Component component, InputDefinition inputForDelete,
+ StorageOperationStatus status) {
// the input is created by 'Declare List'.
// need to 1. undeclare properties, 2. delete input, 3. delete private data type
-
- StorageOperationStatus storageOperationStatus =
- propertyDeclarationOrchestrator.unDeclarePropertiesAsListInputs(component, inputForDelete);
+ StorageOperationStatus storageOperationStatus = propertyDeclarationOrchestrator.unDeclarePropertiesAsListInputs(component, inputForDelete);
if (storageOperationStatus != StorageOperationStatus.OK) {
log.debug("Component id: {} update properties declared as input for input id: {} failed", componentId, inputId);
- return Either.right(componentsUtils.getResponseFormat(
- componentsUtils.convertFromStorageResponse(status), component.getName()));
+ return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(status), component.getName()));
}
- Either<DataTypeDefinition, StorageOperationStatus> deleteResult =
- dataTypeBusinessLogic.deletePrivateDataType(component, inputForDelete.getSchemaType());
+ Either<DataTypeDefinition, StorageOperationStatus> deleteResult = dataTypeBusinessLogic
+ .deletePrivateDataType(component, inputForDelete.getSchemaType());
if (deleteResult.isRight()) {
log.debug("Component id: {} delete datatype name: {} failed", componentId, inputForDelete.getSchemaType());
- return Either.right(componentsUtils.getResponseFormat(
- componentsUtils.convertFromStorageResponse(deleteResult.right().value()), component.getName()));
+ return Either.right(
+ componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(deleteResult.right().value()), component.getName()));
}
log.trace("deleteInput: deletePrivateDataType (OK)");
return Either.left(inputForDelete);
}
- private Either<InputDefinition, ResponseFormat> prepareAndValidateInputBeforeCreate(InputDefinition newInputDefinition, Map<String, DataTypeDefinition> dataTypes) {
-
+ private Either<InputDefinition, ResponseFormat> prepareAndValidateInputBeforeCreate(InputDefinition newInputDefinition,
+ Map<String, DataTypeDefinition> dataTypes) {
// validate input default values
Either<Boolean, ResponseFormat> defaultValuesValidation = validatePropertyDefaultValue(newInputDefinition, dataTypes);
if (defaultValuesValidation.isRight()) {
}
// convert property
ToscaPropertyType type = getType(newInputDefinition.getType());
- if (type != null && newInputDefinition != null) {
+ if (type != null) {
PropertyValueConverter converter = type.getConverter();
// get inner type
SchemaDefinition schema = newInputDefinition.getSchema();
return Either.left(newInputDefinition);
}
- public Either<InputDefinition, ResponseFormat> getInputsAndPropertiesForComponentInput(String userId, String componentId, String inputId, boolean inTransaction) {
+ public Either<InputDefinition, ResponseFormat> getInputsAndPropertiesForComponentInput(String userId, String componentId, String inputId,
+ boolean inTransaction) {
Either<InputDefinition, ResponseFormat> result = null;
try {
-
- validateUserExists(userId, GET_PROPERTIES_BY_INPUT, false);
+ validateUserExists(userId);
ComponentParametersView filters = new ComponentParametersView();
filters.disableAll();
filters.setIgnoreComponentInstances(false);
filters.setIgnoreComponentInstancesInputs(false);
filters.setIgnoreComponentInstancesProperties(false);
filters.setIgnoreProperties(false);
- Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> getComponentEither = toscaOperationFacade.getToscaElement(componentId, filters);
- if(getComponentEither.isRight()){
+ Either<Component, StorageOperationStatus> getComponentEither = toscaOperationFacade
+ .getToscaElement(componentId, filters);
+ if (getComponentEither.isRight()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_COMPONENT_ERROR, componentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
-
}
- org.openecomp.sdc.be.model.Component component = getComponentEither.left().value();
+ Component component = getComponentEither.left().value();
Optional<InputDefinition> op = component.getInputs().stream().filter(in -> in.getUniqueId().equals(inputId)).findFirst();
- if(!op.isPresent()){
+ if (op.isEmpty()) {
ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(getComponentEither.right().value());
log.debug(FAILED_TO_FOUND_INPUT_UNDER_COMPONENT_ERROR, inputId, componentId, actionStatus);
return Either.right(componentsUtils.getResponseFormat(actionStatus));
}
-
InputDefinition resObj = op.get();
-
- List<ComponentInstanceInput> inputCIInput = componentInstanceBusinessLogic.getComponentInstanceInputsByInputId(component, inputId) ;
-
+ List<ComponentInstanceInput> inputCIInput = componentInstanceBusinessLogic.getComponentInstanceInputsByInputId(component, inputId);
resObj.setInputs(inputCIInput);
-
-
- List<ComponentInstanceProperty> inputProps = componentInstanceBusinessLogic.getComponentInstancePropertiesByInputId(component, inputId) ;
-
+ List<ComponentInstanceProperty> inputProps = componentInstanceBusinessLogic.getComponentInstancePropertiesByInputId(component, inputId);
resObj.setProperties(inputProps);
-
-
result = Either.left(resObj);
-
return result;
-
} finally {
-
if (!inTransaction) {
-
if (result == null || result.isRight()) {
log.debug(GOING_TO_EXECUTE_ROLLBACK_ON_CREATE_GROUP);
janusGraphDao.rollback();
log.debug(GOING_TO_EXECUTE_COMMIT_ON_CREATE_GROUP);
janusGraphDao.commit();
}
-
}
-
}
+ }
+ public Either<EntryData<String, InputDefinition>, ResponseFormat> addInputToComponent(String componentId, String inputName,
+ InputDefinition newInputDefinition, String userId) {
+ Either<EntryData<String, InputDefinition>, ResponseFormat> result = null;
+ validateUserExists(userId);
+ Either<Component, StorageOperationStatus> serviceElement = toscaOperationFacade.getToscaElement(componentId);
+ if (serviceElement.isRight()) {
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, ""));
+ return result;
+ }
+ Component component = serviceElement.left().value();
+ NodeTypeEnum nodeType = component.getComponentType().getNodeType();
+ StorageOperationStatus lockResult = graphLockOperation.lockComponent(componentId, nodeType);
+ if (!lockResult.equals(StorageOperationStatus.OK)) {
+ BeEcompErrorManager.getInstance().logBeFailedLockObjectError(CREATE_INPUT, nodeType.name().toLowerCase(), componentId);
+ log.info("Failed to lock component {}. Error - {}", componentId, lockResult);
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
+ return result;
+ }
+ try {
+ if (!ComponentValidationUtils.canWorkOnComponent(component, userId)) {
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
+ return result;
+ }
+ List<InputDefinition> inputs = component.getInputs();
+ if (CollectionUtils.isEmpty(inputs)) {
+ inputs = new ArrayList<>();
+ }
+ if (isInputExistInComponent(inputs, inputName)) {
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.INPUT_ALREADY_EXIST, inputName));
+ return result;
+ }
+ Map<String, DataTypeDefinition> allDataTypes = componentsUtils.getAllDataTypes(applicationDataTypeCache, component.getModel());
+ // validate input default values
+ Either<Boolean, ResponseFormat> defaultValuesValidation = validatePropertyDefaultValue(newInputDefinition, allDataTypes);
+ if (defaultValuesValidation.isRight()) {
+ result = Either.right(defaultValuesValidation.right().value());
+ return result;
+ }
+ // convert Input
+ ToscaPropertyType type = getType(newInputDefinition.getType());
+ if (type != null) {
+ PropertyValueConverter converter = type.getConverter();
+ // get inner type
+ String innerType = null;
+ SchemaDefinition schema = newInputDefinition.getSchema();
+ if (schema != null) {
+ PropertyDataDefinition prop = schema.getProperty();
+ if (prop != null) {
+ innerType = prop.getType();
+ }
+ }
+ if (newInputDefinition.getDefaultValue() != null) {
+ String convertedValue = converter.convert(newInputDefinition.getDefaultValue(), innerType, allDataTypes);
+ newInputDefinition.setDefaultValue(convertedValue);
+ }
+ }
+ newInputDefinition.setMappedToComponentProperty(false);
+ Either<InputDefinition, StorageOperationStatus> addInputEither = toscaOperationFacade
+ .addInputToComponent(inputName, newInputDefinition, component);
+ if (addInputEither.isRight()) {
+ log.info("Failed to add new input {}. Error - {}", componentId, addInputEither.right().value());
+ result = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
+ return result;
+ }
+ result = Either.left(new EntryData<>(inputName, newInputDefinition));
+ return result;
+ } finally {
+ commitOrRollback(result);
+ // unlock component
+ graphLockOperation.unlockComponent(componentId, nodeType);
+ }
}
+ private boolean isInputExistInComponent(List<InputDefinition> inputs, String inputName) {
+ return CollectionUtils.isNotEmpty(inputs) && inputs.stream().anyMatch(input -> input.getName().equals(inputName));
+ }
}
Code Review / sdc.git / blobdiff