diff options
Diffstat (limited to 'catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityInstanceOperation.java')
| -rw-r--r-- | catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityInstanceOperation.java | 1215 |
1 files changed, 1215 insertions, 0 deletions
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityInstanceOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityInstanceOperation.java new file mode 100644 index 0000000000..0c4f35fd54 --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/CapabilityInstanceOperation.java @@ -0,0 +1,1215 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.sdc.be.model.operations.impl; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; + +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.graph.datatype.GraphRelation; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.model.CapabilityDefinition; +import org.openecomp.sdc.be.model.ComponentInstanceProperty; +import org.openecomp.sdc.be.model.DataTypeDefinition; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.model.operations.api.ICapabilityInstanceOperation; +import org.openecomp.sdc.be.resources.data.CapabilityData; +import org.openecomp.sdc.be.resources.data.CapabilityInstData; +import org.openecomp.sdc.be.resources.data.ComponentInstanceData; +import org.openecomp.sdc.be.resources.data.PropertyData; +import org.openecomp.sdc.be.resources.data.PropertyValueData; +import org.openecomp.sdc.be.resources.data.UniqueIdData; +import org.openecomp.sdc.common.datastructure.Wrapper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import com.thinkaurelius.titan.core.TitanVertex; + +import fj.data.Either; + +/** + * public class CapabilityInstanceOperation provides methods for CRUD operations for CapabilityInstance on component instance level + * + * @author ns019t + * + */ +@Component("capability-instance-operation") +public class CapabilityInstanceOperation extends AbstractOperation implements ICapabilityInstanceOperation { + + private static Logger log = LoggerFactory.getLogger(CapabilityOperation.class.getName()); + + @Autowired + private PropertyOperation propertyOperation; + + @Autowired + private CapabilityOperation capabilityOperation; + + /** + * String constants for logger + */ + private String statusIs = ". status is "; + private String dot = "."; + private String onGraph = " on graph "; + private String ofRI = " of resource instance "; + private String toCapability = " to capability "; + private String toCI = " to capability instance "; + private String toProperty = " to property "; + private String forRI = " for resource instance "; + private String failedCreateCI = "Failed to create capability instance of capability "; + private String failedAddProperties = "Failed to add properties to capability instance "; + private String ofCI = " of component instance "; + private String failedDeletePropertyValues = "Failed to delete property values of capability instance "; + private String toValue = " to property value "; + private String fromRI = " from resource instance "; + + /** + * create capability instance of capability with property values for resource instance + * + * @param resourceInstanceId + * @param capabilityId + * @param propertyValues + * @param validateCapabilityInstExistence + * @param capabilityName + * @return + */ + @Override + public Either<Map<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> createCapabilityInstanceOfCapabilityWithPropertyValuesForResourceInstance(String resourceInstanceId, String capabilityId, String capabilityName, + List<ComponentInstanceProperty> propertyValues, boolean validateCapabilityInstExistence) { + Wrapper<TitanOperationStatus> errorWrapper = new Wrapper<>(); + Wrapper<CapabilityData> overrideCapabilityDataWrapper = new Wrapper<>(); + Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper = new Wrapper<>(); + Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes = null; + CapabilityInstData createdCapabilityInstance = null; + + Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper = new Wrapper<>(); + Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityRes = null; + Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes = null; + Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesRes = null; + Wrapper<String> createdCapabilityInstanceIdWrapper = new Wrapper<>(); + if (validateCapabilityInstExistence) { + validateCapabilityInstanceExistence(resourceInstanceId, capabilityId, errorWrapper); + } + if (errorWrapper.isEmpty()) { + getCapabilityRes = getCapabilitiesOfResourceInstance(resourceInstanceId, capabilityId, capabilityName, errorWrapper); + } + if (errorWrapper.isEmpty()) { + getCapabilityDefinitionRes = getCapabiityDefinition(resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, getCapabilityRes); + } + if (errorWrapper.isEmpty()) { + createCapabilityRes = createCapabilityInstanceOnGraph(resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, overrideCapabilityDefinitionWrapper, getCapabilityDefinitionRes); + } + if (errorWrapper.isEmpty() && overrideCapabilityDefinitionWrapper.getInnerElement().getProperties() != null) { + createdCapabilityInstance = validateCapabilityInstanceProperties(resourceInstanceId, propertyValues, errorWrapper, overrideCapabilityDefinitionWrapper, createCapabilityRes, defaultPropertiesWrapper, createdCapabilityInstanceIdWrapper); + } + if (errorWrapper.isEmpty()) { + addPropertyValuesRes = addPropertyValueToCapabilityInstance(resourceInstanceId, propertyValues, errorWrapper, createCapabilityRes, defaultPropertiesWrapper, createdCapabilityInstanceIdWrapper); + } + Either<Map<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> result; + if (errorWrapper.isEmpty()) { + Map<CapabilityInstData, List<PropertyValueData>> resultMap = new HashMap<>(); + resultMap.put(createdCapabilityInstance, addPropertyValuesRes.left().value()); + result = Either.left(resultMap); + } else { + result = Either.right(errorWrapper.getInnerElement()); + } + return result; + } + + @Override + public TitanOperationStatus createCapabilityInstanceOfCapabilityWithPropertyValuesForResourceInstance(TitanVertex resourceInstanceVertex, String resourceInstanceId, String capabilityId, String capabilityName, + List<ComponentInstanceProperty> propertyValues, boolean validateCapabilityInstExistence) { + Wrapper<TitanOperationStatus> errorWrapper = new Wrapper<>(); + Wrapper<TitanVertex> overrideCapabilityDataWrapper = new Wrapper<>(); + Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper = new Wrapper<>(); + Either<TitanVertex, TitanOperationStatus> createCapabilityRes = null; + TitanVertex createdCapabilityInstance = null; + + Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper = new Wrapper<>(); + Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilityRes = null; + Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes = null; + TitanOperationStatus addPropertyValuesRes = null; + Wrapper<String> createdCapabilityInstanceIdWrapper = new Wrapper<>(); + if (validateCapabilityInstExistence) { + validateCapabilityInstanceExistence(resourceInstanceVertex, resourceInstanceId, capabilityId, errorWrapper); + } + if (errorWrapper.isEmpty()) { + getCapabilityRes = getCapabilitiesOfResourceInstance(resourceInstanceVertex, resourceInstanceId, capabilityId, capabilityName, errorWrapper); + } + if (errorWrapper.isEmpty()) { + getCapabilityDefinitionRes = getCapabiityDefinitionByVertex(resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, getCapabilityRes); + } + if (errorWrapper.isEmpty()) { + createCapabilityRes = createCapabilityInstanceOnGraphByVertex(resourceInstanceVertex, resourceInstanceId, capabilityId, errorWrapper, overrideCapabilityDataWrapper, overrideCapabilityDefinitionWrapper, getCapabilityDefinitionRes); + } + if (errorWrapper.isEmpty() && overrideCapabilityDefinitionWrapper.getInnerElement().getProperties() != null) { + createdCapabilityInstance = validateCapabilityInstancePropertiesByVertex(resourceInstanceId, propertyValues, errorWrapper, overrideCapabilityDefinitionWrapper, createCapabilityRes.left().value(), defaultPropertiesWrapper, + createdCapabilityInstanceIdWrapper); + } + if (errorWrapper.isEmpty()) { + addPropertyValuesRes = addPropertyValueToCapabilityInstanceByVertex(resourceInstanceId, propertyValues, errorWrapper, createCapabilityRes, defaultPropertiesWrapper, createdCapabilityInstanceIdWrapper); + } + + return addPropertyValuesRes; + } + + private Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValueToCapabilityInstance(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper, + Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper, Wrapper<String> createdCapabilityInstanceIdWrapper) { + Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesRes; + log.debug("Before adding property values to capability instance {} dot", createdCapabilityInstanceIdWrapper.getInnerElement()); + addPropertyValuesRes = addPropertyValuesToCapabilityInstance(createCapabilityRes.left().value(), propertyValues, defaultPropertiesWrapper.getInnerElement()); + if (addPropertyValuesRes.isRight()) { + errorWrapper.setInnerElement(addPropertyValuesRes.right().value()); + log.debug("failedAddProperties {} ofRI {} statusIs {} dot", createdCapabilityInstanceIdWrapper.getInnerElement(), resourceInstanceId, errorWrapper.getInnerElement()); + } + log.debug("After adding property values to capability instance {} status is {}.", createdCapabilityInstanceIdWrapper.getInnerElement(), errorWrapper.getInnerElement()); + return addPropertyValuesRes; + } + + private TitanOperationStatus addPropertyValueToCapabilityInstanceByVertex(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper, + Either<TitanVertex, TitanOperationStatus> createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper, Wrapper<String> createdCapabilityInstanceIdWrapper) { + log.trace("Before adding property values to capability instance {}", createdCapabilityInstanceIdWrapper.getInnerElement()); + TitanOperationStatus addPropertyValuesRes = addPropertyValuesToCapabilityInstance(createCapabilityRes.left().value(), propertyValues, defaultPropertiesWrapper.getInnerElement()); + if (!addPropertyValuesRes.equals(TitanOperationStatus.OK)) { + errorWrapper.setInnerElement(addPropertyValuesRes); + log.debug("Failed to add properties to capability instance {} {} {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement()); + } + log.trace("After adding property values to capability instance {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), statusIs, errorWrapper.getInnerElement()); + return addPropertyValuesRes; + } + + private CapabilityInstData validateCapabilityInstanceProperties(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper, + Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper, + Wrapper<String> createdCapabilityInstanceIdWrapper) { + CapabilityInstData createdCapabilityInstance; + createdCapabilityInstance = createCapabilityRes.left().value(); + createdCapabilityInstanceIdWrapper.setInnerElement(createdCapabilityInstance.getUniqueId()); + Map<String, PropertyDefinition> defaultProperties = overrideCapabilityDefinitionWrapper.getInnerElement().getProperties().stream().collect(Collectors.toMap(PropertyDefinition::getName, Function.identity())); + defaultPropertiesWrapper.setInnerElement(defaultProperties); + log.debug("Before validating property values of capability instance {}.", createdCapabilityInstanceIdWrapper.getInnerElement()); + Either<Boolean, TitanOperationStatus> result = validateCapabilityInstanceProperties(defaultProperties, propertyValues); + if (result.isRight()) { + errorWrapper.setInnerElement(result.right().value()); + log.debug("failedAddProperties {} ofRI {} statusIs {}.", createdCapabilityInstanceIdWrapper.getInnerElement(), resourceInstanceId, errorWrapper.getInnerElement()); + } + log.debug("After validating property values of capability instance {} status is {}.", createdCapabilityInstanceIdWrapper.getInnerElement(), errorWrapper.getInnerElement()); + return createdCapabilityInstance; + } + + private TitanVertex validateCapabilityInstancePropertiesByVertex(String resourceInstanceId, List<ComponentInstanceProperty> propertyValues, Wrapper<TitanOperationStatus> errorWrapper, + Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, TitanVertex createCapabilityRes, Wrapper<Map<String, PropertyDefinition>> defaultPropertiesWrapper, Wrapper<String> createdCapabilityInstanceIdWrapper) { + String id = (String) titanGenericDao.getProperty(createCapabilityRes, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + createdCapabilityInstanceIdWrapper.setInnerElement(id); + Map<String, PropertyDefinition> defaultProperties = overrideCapabilityDefinitionWrapper.getInnerElement().getProperties().stream().collect(Collectors.toMap(PropertyDefinition::getName, Function.identity())); + defaultPropertiesWrapper.setInnerElement(defaultProperties); + log.trace("Before validating property values of capability instance {}", createdCapabilityInstanceIdWrapper.getInnerElement()); + Either<Boolean, TitanOperationStatus> result = validateCapabilityInstanceProperties(defaultProperties, propertyValues); + if (result.isRight()) { + errorWrapper.setInnerElement(result.right().value()); + log.debug("Failed to add properties to capability instance {} {} {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement()); + } + log.trace("After validating property values of capability instance {} {} {}", createdCapabilityInstanceIdWrapper.getInnerElement(), statusIs, errorWrapper.getInnerElement()); + return createCapabilityRes; + } + + private Either<CapabilityInstData, TitanOperationStatus> createCapabilityInstanceOnGraph(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper, Wrapper<CapabilityData> overrideCapabilityDataWrapper, + Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes) { + Either<CapabilityInstData, TitanOperationStatus> createCapabilityRes; + log.debug("Before creating capability instance of capability {} on graph.", capabilityId); + overrideCapabilityDefinitionWrapper.setInnerElement(getCapabilityDefinitionRes.left().value()); + CapabilityInstData capabilityInstance = buildCapabilityInstanceData(resourceInstanceId, overrideCapabilityDefinitionWrapper.getInnerElement()); + createCapabilityRes = createCapabilityInstanceOnGraph(resourceInstanceId, overrideCapabilityDataWrapper.getInnerElement(), capabilityInstance); + if (createCapabilityRes.isRight()) { + errorWrapper.setInnerElement(createCapabilityRes.right().value()); + log.debug("failedCreateCI {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + log.debug("After creating capability instance of capability {} on graph. Status is {}", capabilityId, errorWrapper.getInnerElement()); + return createCapabilityRes; + } + + private Either<TitanVertex, TitanOperationStatus> createCapabilityInstanceOnGraphByVertex(TitanVertex riVertex, String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper, + Wrapper<TitanVertex> overrideCapabilityDataWrapper, Wrapper<CapabilityDefinition> overrideCapabilityDefinitionWrapper, Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes) { + Either<TitanVertex, TitanOperationStatus> createCapabilityRes; + log.trace("Before creating capability instance of capability {} {}", capabilityId, onGraph); + overrideCapabilityDefinitionWrapper.setInnerElement(getCapabilityDefinitionRes.left().value()); + CapabilityInstData capabilityInstance = buildCapabilityInstanceData(resourceInstanceId, overrideCapabilityDefinitionWrapper.getInnerElement()); + createCapabilityRes = createCapabilityInstanceOnGraph(riVertex, resourceInstanceId, overrideCapabilityDataWrapper.getInnerElement(), capabilityInstance); + if (createCapabilityRes.isRight()) { + errorWrapper.setInnerElement(createCapabilityRes.right().value()); + log.debug("Failed to create capability instance of capability {} {} {} {} {} ", capabilityId, ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement()); + } + log.debug("After creating capability instance of capability {} {} {} {} {}", capabilityId, onGraph, statusIs, errorWrapper.getInnerElement()); + return createCapabilityRes; + } + + private Either<CapabilityDefinition, TitanOperationStatus> getCapabiityDefinition(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper, Wrapper<CapabilityData> overrideCapabilityDataWrapper, + Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityRes) { + Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes; + log.debug("Before getting capability definition {} forRI {}.", capabilityId, resourceInstanceId); + CapabilityData overrideCapabilityData = getCapabilityRes.left().value().getLeft(); + overrideCapabilityDataWrapper.setInnerElement(overrideCapabilityData); + getCapabilityDefinitionRes = capabilityOperation.getCapabilityByCapabilityData(overrideCapabilityData); + if (getCapabilityDefinitionRes.isRight()) { + errorWrapper.setInnerElement(getCapabilityDefinitionRes.right().value()); + log.debug("Failed to retrieve capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + log.debug("After getting capability definition for {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + return getCapabilityDefinitionRes; + } + + private Either<CapabilityDefinition, TitanOperationStatus> getCapabiityDefinitionByVertex(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper, Wrapper<TitanVertex> overrideCapabilityDataWrapper, + Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilityRes) { + Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes; + log.trace("Before getting capability definition {} {} {}", capabilityId, forRI, resourceInstanceId); + + TitanVertex overrideCapabilityData = getCapabilityRes.left().value().getLeft(); + + overrideCapabilityDataWrapper.setInnerElement(overrideCapabilityData); + getCapabilityDefinitionRes = capabilityOperation.getCapabilityByCapabilityData(overrideCapabilityData); + if (getCapabilityDefinitionRes.isRight()) { + errorWrapper.setInnerElement(getCapabilityDefinitionRes.right().value()); + log.debug("Failed to retrieve capability {} ofRI {} statusIs {}", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + log.debug("After getting capability definition for {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + return getCapabilityDefinitionRes; + } + + private Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilitiesOfResourceInstance(String resourceInstanceId, String capabilityId, String capabilityName, Wrapper<TitanOperationStatus> errorWrapper) { + Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityRes; + log.debug("Before getting capability {} forRI {}.", capabilityId, resourceInstanceId); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.NAME.getProperty(), capabilityName); + getCapabilityRes = titanGenericDao.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, GraphEdgeLabels.CALCULATED_CAPABILITY, NodeTypeEnum.Capability, CapabilityData.class, props); + if (getCapabilityRes.isRight()) { + errorWrapper.setInnerElement(getCapabilityRes.right().value()); + log.debug("Failed to get capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + log.debug("After getting capability for {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + return getCapabilityRes; + } + + private Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilitiesOfResourceInstance(TitanVertex instanceVertex, String resourceInstanceId, String capabilityId, String capabilityName, + Wrapper<TitanOperationStatus> errorWrapper) { + Either<ImmutablePair<TitanVertex, Edge>, TitanOperationStatus> getCapabilityRes; + log.trace("Before getting capability {} {} {}", capabilityId, forRI, resourceInstanceId); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.NAME.getProperty(), capabilityName); + getCapabilityRes = titanGenericDao.getChildByEdgeCriteria(instanceVertex, GraphEdgeLabels.CALCULATED_CAPABILITY, props); + if (getCapabilityRes.isRight()) { + errorWrapper.setInnerElement(getCapabilityRes.right().value()); + log.debug("Failed to get capability {} {} {} {} {}", capabilityId, ofRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement()); + } + log.trace("After getting capability for {} {} {} {} {}", capabilityId, forRI, resourceInstanceId, statusIs, errorWrapper.getInnerElement()); + return getCapabilityRes; + } + + private void validateCapabilityInstanceExistence(String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper) { + log.debug("Before validation of existence of capability instance of capability {} forRI {}.", capabilityId, resourceInstanceId); + boolean capabilityInstOfCapabilityAlreadyExists; + Either<Boolean, TitanOperationStatus> validateCapabilityInstExistenceRes = validateCapabilityInstExistence(resourceInstanceId, capabilityId); + if (validateCapabilityInstExistenceRes.isRight()) { + errorWrapper.setInnerElement(validateCapabilityInstExistenceRes.right().value()); + log.debug("Failed to validate uniqueness of capability instance of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } else { + capabilityInstOfCapabilityAlreadyExists = validateCapabilityInstExistenceRes.left().value(); + if (capabilityInstOfCapabilityAlreadyExists) { + errorWrapper.setInnerElement(TitanOperationStatus.ALREADY_EXIST); + log.debug("failedCreateCI {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + } + log.debug("After validation of existence of capability instance of capability {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + + private void validateCapabilityInstanceExistence(TitanVertex resourceInstanceVertex, String resourceInstanceId, String capabilityId, Wrapper<TitanOperationStatus> errorWrapper) { + log.trace("Before validation of existence of capability instance of capability {} {} {}", capabilityId, forRI, resourceInstanceId); + boolean capabilityInstOfCapabilityAlreadyExists; + Either<Boolean, TitanOperationStatus> validateCapabilityInstExistenceRes = validateCapabilityInstExistence(resourceInstanceId, capabilityId); + if (validateCapabilityInstExistenceRes.isRight()) { + errorWrapper.setInnerElement(validateCapabilityInstExistenceRes.right().value()); + log.debug("Failed to validate uniqueness of capability instance of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } else { + capabilityInstOfCapabilityAlreadyExists = validateCapabilityInstExistenceRes.left().value(); + if (capabilityInstOfCapabilityAlreadyExists) { + errorWrapper.setInnerElement(TitanOperationStatus.ALREADY_EXIST); + log.debug("failedCreateCI {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + } + log.debug("After validation of existence of capability instance of capability {} forRI {} statusIs {}.", capabilityId, resourceInstanceId, errorWrapper.getInnerElement()); + } + + private Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesToCapabilityInstance(CapabilityInstData createdCapabilityInstance, List<ComponentInstanceProperty> propertyValues, Map<String, PropertyDefinition> defaultProperties) { + TitanOperationStatus error = null; + List<PropertyValueData> createdPropertyValues = new ArrayList<>(); + for (ComponentInstanceProperty property : propertyValues) { + log.debug("Before adding property value {} toCI {}.", property.getName(), createdCapabilityInstance.getUniqueId()); + PropertyValueData propertyData = buildPropertyValueData(property.getName(), property.getType(), property.getValue(), createdCapabilityInstance.getUniqueId()); + Either<PropertyValueData, TitanOperationStatus> addPropertyValueRes = addPropertyValueToCapabilityInstance(createdCapabilityInstance, propertyData, defaultProperties.get(property.getName())); + if (addPropertyValueRes.isRight()) { + error = addPropertyValueRes.right().value(); + log.debug("Failed to add property to capability instance {} ofRI. StatusIs {}.", createdCapabilityInstance.getUniqueId(), error); + break; + } else { + createdPropertyValues.add(addPropertyValueRes.left().value()); + } + log.debug("After adding property value {} toCI {} statusIs {}", property.getName(), createdCapabilityInstance.getUniqueId(), error); + } + if (error == null) { + return Either.left(createdPropertyValues); + } + return Either.right(error); + } + + private TitanOperationStatus addPropertyValuesToCapabilityInstance(TitanVertex createdCapabilityInstancevertex, List<ComponentInstanceProperty> propertyValues, Map<String, PropertyDefinition> defaultProperties) { + TitanOperationStatus error = null; + String id = (String) titanGenericDao.getProperty(createdCapabilityInstancevertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + for (ComponentInstanceProperty property : propertyValues) { + log.trace("Before adding property value {} {} {}", property.getName(), toCI, id); + PropertyValueData propertyData = buildPropertyValueData(property.getName(), property.getType(), property.getValue(), id); + TitanOperationStatus addPropertyValueRes = addPropertyValueToCapabilityInstance(createdCapabilityInstancevertex, propertyData, defaultProperties.get(property.getName()), id); + if (!addPropertyValueRes.equals(TitanOperationStatus.OK)) { + error = addPropertyValueRes; + log.debug("Failed to add property to capability instance {} {} {} {}", id, ofRI, statusIs, error); + break; + } + log.debug("After adding property value {} {} {} {} {}", property.getName(), toCI, id, statusIs, error); + } + if (error == null) { + return TitanOperationStatus.OK; + } + return error; + } + + private PropertyValueData buildPropertyValueData(String propertyName, String propertyType, String propertyValue, String capabilityInstanceId) { + PropertyValueData propertyData = new PropertyValueData(); + String uniqueId = UniqueIdBuilder.buildPropertyValueUniqueId(capabilityInstanceId, propertyName); + Long creationTime = System.currentTimeMillis(); + propertyData.setUniqueId(uniqueId); + propertyData.setValue(propertyValue); + propertyData.setType(propertyType); + propertyData.setCreationTime(creationTime); + propertyData.setModificationTime(creationTime); + return propertyData; + } + + private Either<PropertyValueData, TitanOperationStatus> addPropertyValueToCapabilityInstance(CapabilityInstData createdCapabilityInstance, PropertyValueData propertyValue, PropertyDefinition propertyDefinition) { + TitanOperationStatus error = null; + Map<String, Object> props = null; + Either<GraphRelation, TitanOperationStatus> createRelationRes; + PropertyValueData createdValue = null; + log.debug("Before creating property value node {} onGraph.", propertyValue.getUniqueId()); + Either<PropertyValueData, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue, PropertyValueData.class); + if (createValueRes.isRight()) { + error = createValueRes.right().value(); + log.debug("Failed to create property value for capability instance {} ofRI statusIs {}.", createdCapabilityInstance.getUniqueId(), error); + } + log.debug("After creating property value node {} onGraph statusIs {}.", propertyValue.getUniqueId(), error); + if (error == null) { + log.debug("Before creating relation from property value node {} toCI {}.", propertyValue.getUniqueId(), createdCapabilityInstance.getUniqueId()); + createdValue = createValueRes.left().value(); + props = new HashMap<>(); + props.put(GraphPropertiesDictionary.PROPERTY_NAME.name(), propertyDefinition.getName()); + props.put(GraphPropertiesDictionary.PROPERTY_ID.name(), propertyDefinition.getUniqueId()); + createRelationRes = titanGenericDao.createRelation(createdCapabilityInstance, createdValue, GraphEdgeLabels.PROPERTY_VALUE, props); + if (createRelationRes.isRight()) { + error = createRelationRes.right().value(); + log.debug("Failed to create relation from capability instance {} toValue {} statusIs {}.", createdCapabilityInstance.getUniqueId(), createdValue.getUniqueId(), error); + } + log.debug("After creating relation from property value node {} toCI {} statusIs {}.", propertyValue.getUniqueId(), createdCapabilityInstance.getUniqueId(), error); + } + if (error == null) { + log.debug("Before creating relation from property value node {} toProperty {}.", propertyValue.getUniqueId(), propertyDefinition.getUniqueId()); + createRelationRes = titanGenericDao.createRelation(propertyValue, new PropertyData(propertyDefinition, null), GraphEdgeLabels.PROPERTY_IMPL, props); + if (createRelationRes.isRight()) { + error = createRelationRes.right().value(); + log.debug("Failed to create relation from property value {} toProperty {} statusIs {}.", createdValue.getUniqueId(), propertyDefinition.getUniqueId(), error); + } + log.debug("After creating relation from property value node {} toProperty statusIs {}.", propertyValue.getUniqueId(), propertyDefinition.getUniqueId(), error); + } + if (error == null) { + return Either.left(createdValue); + } + return Either.right(error); + } + + private TitanOperationStatus addPropertyValueToCapabilityInstance(TitanVertex createdCapabilityInstanceVertex, PropertyValueData propertyValue, PropertyDefinition propertyDefinition, String id) { + TitanOperationStatus error = null; + Map<String, Object> props = null; + TitanOperationStatus createRelationRes; + log.trace("Before creating property value node {} on graph.", propertyValue.getUniqueId()); + Either<TitanVertex, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue); + if (createValueRes.isRight()) { + error = createValueRes.right().value(); + if (log.isDebugEnabled()){ + log.debug("Failed to create property value for capability instance {} {} {} {}", id, ofRI, statusIs, error); + } + } + log.trace("After creating property value node {} on graph status is {}", propertyValue.getUniqueId(), error); + TitanVertex createdPropVertex = null; + String createdId = null; + if (error == null) { + log.trace("Before creating relation from property value node {} {} {} ", propertyValue.getUniqueId(), toCI, id); + props = new HashMap<>(); + props.put(GraphPropertiesDictionary.PROPERTY_NAME.name(), propertyDefinition.getName()); + props.put(GraphPropertiesDictionary.PROPERTY_ID.name(), propertyDefinition.getUniqueId()); + createdPropVertex = createValueRes.left().value(); + createRelationRes = titanGenericDao.createEdge(createdCapabilityInstanceVertex, createdPropVertex, GraphEdgeLabels.PROPERTY_VALUE, props); + if (!createRelationRes.equals(TitanOperationStatus.OK)) { + error = createRelationRes; + createdId = (String) titanGenericDao.getProperty(createdPropVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + if (log.isDebugEnabled()) { + log.debug("Failed to create relation from capability instance {} {} {} {} {}", id, toValue, createdId, statusIs, error); + } + } + if (log.isTraceEnabled()){ + log.trace("After creating relation from property value node {} {} {} {} {}", propertyValue.getUniqueId(), toCI, id, statusIs, error); + } + } + if (error == null) { + log.trace("Before creating relation from property value node {} {} {}", propertyValue.getUniqueId(), toProperty, propertyDefinition.getUniqueId()); + createRelationRes = titanGenericDao.createEdge(createdPropVertex, new PropertyData(propertyDefinition, null), GraphEdgeLabels.PROPERTY_IMPL, props); + if (!createRelationRes.equals(TitanOperationStatus.OK)) { + error = createRelationRes; + log.debug("Failed to create relation from property value {} {} {} {} {}", createdId, toProperty, propertyDefinition.getUniqueId(), statusIs, error); + } + log.debug("After creating relation from property value node {} {} {} {} {}", propertyValue.getUniqueId(), toProperty, propertyDefinition.getUniqueId(), statusIs, error); + } + if (error == null) { + return TitanOperationStatus.OK; + } + return error; + } + + private Either<Boolean, TitanOperationStatus> validateCapabilityInstanceProperties(Map<String, PropertyDefinition> defaultProperties, List<ComponentInstanceProperty> propertyValues) { + Either<Boolean, TitanOperationStatus> result = Either.left(true); + for (ComponentInstanceProperty property : propertyValues) { + result = validateUpdateCapabilityInstancePropertyValue(property, defaultProperties); + if (result.isRight()) { + break; + } + } + return result; + } + + private Either<Boolean, TitanOperationStatus> validateUpdateCapabilityInstancePropertyValue(ComponentInstanceProperty property, Map<String, PropertyDefinition> defaultProperties) { + PropertyDefinition defaultProperty; + String propertyName = property.getName(); + Either<Boolean, TitanOperationStatus> result = null; + if (defaultProperties.containsKey(propertyName)) { + defaultProperty = defaultProperties.get(propertyName); + String propertyType = property.getType() == null || property.getType().isEmpty() ? defaultProperty.getType() : property.getType(); + + String innerType = null; + if (property.getSchema() != null && property.getSchema().getProperty() != null) + innerType = property.getSchema().getProperty().getType(); + if (innerType == null && defaultProperty.getSchema() != null && defaultProperty.getSchema().getProperty() != null) + innerType = defaultProperty.getSchema().getProperty().getType(); + + if (defaultProperty.getType().equals(propertyType)) { + String propertyValue = property.getValue(); + Either<Map<String, DataTypeDefinition>, TitanOperationStatus> allDataTypes = applicationDataTypeCache.getAll(); + if (allDataTypes.isRight()) { + TitanOperationStatus status = allDataTypes.right().value(); + log.debug("Failed to update property value statusIs {}.", status); + result = Either.right(status); + } + if (result == null) { + Either<Object, Boolean> updatedPropertyValueRes = propertyOperation.validateAndUpdatePropertyValue(propertyType, propertyValue, innerType, allDataTypes.left().value()); + if (updatedPropertyValueRes.isLeft()) { + if (updatedPropertyValueRes.left().value() != null) + property.setDefaultValue(updatedPropertyValueRes.left().value().toString()); + result = Either.left(true); + } else { + result = Either.right(TitanOperationStatus.INVALID_PROPERTY); + } + } + log.debug("The property with name {} has invalid type {} or invalid value {}.", propertyName, propertyType, propertyValue); + + } else { + result = Either.right(TitanOperationStatus.PROPERTY_NAME_ALREADY_EXISTS); + log.debug("The property with name {} and different type already exists.", propertyName); + } + } else { + result = Either.right(TitanOperationStatus.NOT_FOUND); + log.debug("Failed to find property with name {}.", propertyName); + } + return result; + } + + /** + * validate capability instance uniqueness + * + * @param resourceInstanceId + * @param capabilityId + * @return + */ + @Override + public Either<Boolean, TitanOperationStatus> validateCapabilityInstExistence(String resourceInstanceId, String capabilityId) { + Either<Boolean, TitanOperationStatus> result = null; + TitanOperationStatus error; + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId); + Either<Edge, TitanOperationStatus> getCapabilityInstanceEdgeRes = titanGenericDao.getOutgoingEdgeByCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, GraphEdgeLabels.CAPABILITY_INST, props); + if (getCapabilityInstanceEdgeRes.isRight()) { + error = getCapabilityInstanceEdgeRes.right().value(); + if (error.equals(TitanOperationStatus.NOT_FOUND)) { + result = Either.left(false); + } else { + log.debug("Failed to get outgoing edge for resource instance {} statusIs {}.", resourceInstanceId, error); + result = Either.right(error); + } + } + if (result == null) { + result = Either.left(true); + } + return result; + } + + @Override + public Either<Boolean, TitanOperationStatus> validateCapabilityInstExistence(TitanVertex instanceVertex, String resourceInstanceId, String capabilityId) { + Either<Boolean, TitanOperationStatus> result = null; + TitanOperationStatus error; + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId); + Either<Edge, TitanOperationStatus> getCapabilityInstanceEdgeRes = titanGenericDao.getOutgoingEdgeByCriteria(instanceVertex, GraphEdgeLabels.CAPABILITY_INST, props); + if (getCapabilityInstanceEdgeRes.isRight()) { + error = getCapabilityInstanceEdgeRes.right().value(); + if (error.equals(TitanOperationStatus.NOT_FOUND)) { + result = Either.left(false); + } else { + log.debug("Failed to get outgoing edge for resource instance {} {} {}", resourceInstanceId, statusIs, error); + result = Either.right(error); + } + } + if (result == null) { + result = Either.left(true); + } + return result; + } + + private Either<CapabilityInstData, TitanOperationStatus> createCapabilityInstanceOnGraph(String resourceInstanceId, CapabilityData overrideCapabilityData, CapabilityInstData capabilityInstance) { + log.debug("Before creation of capability instance of capability {} forRI {}.", overrideCapabilityData.getUniqueId(), resourceInstanceId); + + Either<GraphRelation, TitanOperationStatus> createRelationRes; + CapabilityInstData createdCapabilityInstance = null; + String capabilityInstanceId = null; + TitanOperationStatus error = null; + Either<CapabilityInstData, TitanOperationStatus> createCapabilityInstanceRes = titanGenericDao.createNode(capabilityInstance, CapabilityInstData.class); + if (createCapabilityInstanceRes.isRight()) { + error = createCapabilityInstanceRes.right().value(); + log.debug("failedCreateCI {} forRI {} statusIs {}.", overrideCapabilityData.getUniqueId(), resourceInstanceId, error); + } + log.debug("After creation of capability instance of capability {} forRI {} statusIs {}.", overrideCapabilityData.getUniqueId(), resourceInstanceId, error); + if (error == null) { + createdCapabilityInstance = createCapabilityInstanceRes.left().value(); + capabilityInstanceId = createdCapabilityInstance.getUniqueId(); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityData.getUniqueId()); + UniqueIdData resourceInstanceIdData = new UniqueIdData(NodeTypeEnum.ResourceInstance, resourceInstanceId); + log.debug("Before associating resource instance {} to capability instance.", resourceInstanceId); + createRelationRes = titanGenericDao.createRelation(resourceInstanceIdData, capabilityInstance, GraphEdgeLabels.CAPABILITY_INST, props); + if (createRelationRes.isRight()) { + error = createRelationRes.right().value(); + log.debug("Failed to assotiate resource instance {} toCI {} statusIs {}.", resourceInstanceId, capabilityInstanceId, error); + } + log.debug("After associating resource instance {} to CI {} statusIs {}.", resourceInstanceId, capabilityInstanceId, error); + } + if (error == null) { + log.debug("Before associating capability instance {} toCapability {}.", capabilityInstanceId, overrideCapabilityData.getUniqueId()); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityData.getUniqueId()); + createRelationRes = titanGenericDao.createRelation(createdCapabilityInstance, overrideCapabilityData, GraphEdgeLabels.INSTANCE_OF, props); + if (createRelationRes.isRight()) { + error = createRelationRes.right().value(); + log.debug("Failed to associate capability instance {} toCapability statusIs {}.", capabilityInstanceId, overrideCapabilityData.getUniqueId(), error); + } + log.debug("After associating capability instance {} toCapability statusIs {}.", capabilityInstanceId, overrideCapabilityData.getUniqueId(), error); + } + if (error == null) { + return createCapabilityInstanceRes; + } + return Either.right(error); + } + + private Either<TitanVertex, TitanOperationStatus> createCapabilityInstanceOnGraph(TitanVertex riVertex, String resourceInstanceId, TitanVertex overrideCapabilityDataVertex, CapabilityInstData capabilityInstance) { + String overrideCapabilityDataId = (String) titanGenericDao.getProperty(overrideCapabilityDataVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + log.trace("Before creation of capability instance of capability {} {} {}", overrideCapabilityDataVertex, forRI, resourceInstanceId); + + TitanOperationStatus createRelationRes; + TitanVertex createdCapabilityInstance = null; + String capabilityInstanceId = null; + TitanOperationStatus error = null; + Either<TitanVertex, TitanOperationStatus> createCapabilityInstanceRes = titanGenericDao.createNode(capabilityInstance); + if (createCapabilityInstanceRes.isRight()) { + error = createCapabilityInstanceRes.right().value(); + log.debug("Failed to create capability instance of capability {} {} {} {} {}", overrideCapabilityDataId, forRI, resourceInstanceId, statusIs, error); + } + log.trace("After creation of capability instance of capability {} {} {} {} {}", overrideCapabilityDataId, forRI, resourceInstanceId, statusIs, error); + if (error == null) { + createdCapabilityInstance = createCapabilityInstanceRes.left().value(); + capabilityInstanceId = (String) titanGenericDao.getProperty(createdCapabilityInstance, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityDataId); + log.debug("Before associating resource instance {} to capability instance.", resourceInstanceId); + + createRelationRes = titanGenericDao.createEdge(riVertex, capabilityInstance, GraphEdgeLabels.CAPABILITY_INST, props); + if (!createRelationRes.equals(TitanOperationStatus.OK)) { + error = createRelationRes; + log.debug("Failed to assotiate resource instance {} {} {} {} {}", resourceInstanceId, toCI, capabilityInstanceId, statusIs, error); + } + if (log.isTraceEnabled()) { + log.trace("After associating resource instance {} {} {} {} {}", resourceInstanceId, toCI, capabilityInstanceId, statusIs, error); + } + } + if (error == null) { + log.trace("Before associating capability instance {} {} {}", capabilityInstanceId, toCapability, overrideCapabilityDataId); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), overrideCapabilityDataId); + createRelationRes = titanGenericDao.createEdge(createdCapabilityInstance, overrideCapabilityDataVertex, GraphEdgeLabels.INSTANCE_OF, props); + if (!createRelationRes.equals(TitanOperationStatus.OK)) { + error = createRelationRes; + log.debug("Failed to associate capability instance {} {} {} {} {}", capabilityInstanceId, toCapability, overrideCapabilityDataId, statusIs, error); + } + log.debug("After associating capability instance {} {} {} {} {}", capabilityInstanceId, toCapability, overrideCapabilityDataId, statusIs, error); + } + if (error == null) { + return createCapabilityInstanceRes; + } + return Either.right(error); + } + + private CapabilityInstData buildCapabilityInstanceData(String resourceInstanceId, CapabilityDefinition capability) { + CapabilityInstData capabilityInstance = new CapabilityInstData(); + Long creationTime = System.currentTimeMillis(); + String uniqueId = UniqueIdBuilder.buildCapabilityInstanceUid(resourceInstanceId, capability.getName()); + + capabilityInstance.setCreationTime(creationTime); + capabilityInstance.setModificationTime(creationTime); + capabilityInstance.setUniqueId(uniqueId); + + return capabilityInstance; + } + + /** + * delete capability instance from resource instance + * + * @param resourceInstanceId + * @param capabilityInstanceId + * @return + */ + @Override + public Either<CapabilityInstData, TitanOperationStatus> deleteCapabilityInstanceFromResourceInstance(String resourceInstanceId, String capabilityInstanceId) { + log.debug("Before deleting of capability instance {} fromRI {}.", capabilityInstanceId, resourceInstanceId); + + Either<CapabilityInstData, TitanOperationStatus> deleteCapabilityInstRes = null; + TitanOperationStatus error = null; + Either<Boolean, TitanOperationStatus> deleteProperyValuesRes = deleteAllPropertyValuesOfCapabilityInstance(resourceInstanceId, capabilityInstanceId); + if (deleteProperyValuesRes.isRight()) { + error = deleteProperyValuesRes.right().value(); + log.debug("failedDeletePropertyValues {} for RI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error); + } + if (error == null) { + deleteCapabilityInstRes = titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstanceId, CapabilityInstData.class); + if (deleteCapabilityInstRes.isRight()) { + error = deleteCapabilityInstRes.right().value(); + log.debug("Failed to delete capability instance {} forRI {} statusIs {}", capabilityInstanceId, resourceInstanceId, error); + } + } + log.debug("After deleting of capability instance {} fromRI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error); + if (error == null) { + return Either.left(deleteCapabilityInstRes.left().value()); + } + return Either.right(error); + } + + private Either<Boolean, TitanOperationStatus> deleteAllPropertyValuesOfCapabilityInstance(String resourceInstanceId, String capabilityInstanceId) { + log.debug("Before deleting all property values of capability instance {} fromRI {}.", capabilityInstanceId, resourceInstanceId); + TitanOperationStatus error = null; + List<ImmutablePair<PropertyValueData, GraphEdge>> deletePropertiesPairs; + Either<List<ImmutablePair<PropertyValueData, GraphEdge>>, TitanOperationStatus> getPropertyValuesRes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstanceId, + GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class); + if (getPropertyValuesRes.isRight()) { + error = getPropertyValuesRes.right().value(); + log.debug("Failed to retrieve property values of capability instance {} forRI {} status {}.", capabilityInstanceId, resourceInstanceId, error); + } + if (error == null) { + deletePropertiesPairs = getPropertyValuesRes.left().value(); + for (ImmutablePair<PropertyValueData, GraphEdge> propertyPair : deletePropertiesPairs) { + Either<PropertyValueData, TitanOperationStatus> deletePropertyRes = titanGenericDao.deleteNode(propertyPair.getLeft(), PropertyValueData.class); + if (deletePropertyRes.isRight()) { + error = deletePropertyRes.right().value(); + log.debug("failedDeletePropertyValues {} forRI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error); + break; + } + } + } + log.debug("After deleting all property values of capability instance {} fromRI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error); + if (error == null) { + return Either.left(true); + } + return Either.right(error); + } + + /** + * get all capability instances for resource instance returns all Capability Instances related to Resource Instance as List<CapabilityInstData> or TitanOperationStatus if error occurs or if Resource Instance have no any related Capability + * Instance + * + * @param resourceInstanceId + * @return Either<List<CapabilityInstData>, TitanOperationStatus> + */ + @Override + public Either<List<ImmutablePair<CapabilityInstData, GraphEdge>>, TitanOperationStatus> getAllCapabilityInstancesOfResourceInstance(String resourceInstanceId) { + log.debug("Before deleting all capability instances of resource instance {}.", resourceInstanceId); + TitanOperationStatus error = null; + Either<List<ImmutablePair<CapabilityInstData, GraphEdge>>, TitanOperationStatus> getCapabilityInstancesRes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, + GraphEdgeLabels.CAPABILITY_INST, NodeTypeEnum.CapabilityInst, CapabilityInstData.class); + if (getCapabilityInstancesRes.isRight()) { + error = getCapabilityInstancesRes.right().value(); + log.debug("Failed to retrieve capability Instances of resource instance {} statusIs {}.", resourceInstanceId, error); + } + log.debug("After deleting all capability instances of resource instance {} statusIs {}", resourceInstanceId, error); + if (error == null) { + return getCapabilityInstancesRes; + } + return Either.right(error); + } + + /** + * get capability instance of capability for resource instance + * + * @param resourceInstanceId + * @param capabilityId + * @return + */ + @Override + public Either<CapabilityInstData, TitanOperationStatus> getCapabilityInstanceOfCapabilityOfResourceInstance(String resourceInstanceId, String capabilityId) { + TitanOperationStatus error = null; + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId); + Either<ImmutablePair<CapabilityInstData, GraphEdge>, TitanOperationStatus> getCapabilityInstanceRes = titanGenericDao.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, + GraphEdgeLabels.CAPABILITY_INST, NodeTypeEnum.CapabilityInst, CapabilityInstData.class, props); + if (getCapabilityInstanceRes.isRight()) { + error = getCapabilityInstanceRes.right().value(); + log.debug("Failed to retrieve capability Instance of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error); + } + if (error == null) { + return Either.left(getCapabilityInstanceRes.left().value().getLeft()); + } + return Either.right(error); + } + + /** + * update capability property values + * + * @param resourceInstanceId + * @param propertyValues + * @param capabilityId + * @return + */ + @Override + public Either<List<PropertyValueData>, TitanOperationStatus> updateCapabilityPropertyValues(String resourceInstanceId, String capabilityId, List<ComponentInstanceProperty> propertyValues) { + log.debug("Before updating property values of capability {} ofRI {}.", capabilityId, resourceInstanceId); + TitanOperationStatus error = null; + Map<String, Object> props = new HashMap<>(); + CapabilityInstData capabilityInstance = null; + String capabilityInstanceId = null; + Either<Boolean, TitanOperationStatus> deleteProperyValuesRes; + + CapabilityData overrideCapabilityData; + CapabilityDefinition overrideCapabilityDefinition; + Map<String, PropertyDefinition> defaultProperties = null; + Either<ImmutablePair<CapabilityData, GraphEdge>, TitanOperationStatus> getCapabilityDataRes = null; + Either<List<PropertyValueData>, TitanOperationStatus> addPropertyValuesRes = null; + Either<CapabilityDefinition, TitanOperationStatus> getCapabilityDefinitionRes = null; + + log.debug("Before getting all capability instances of RI {}.", resourceInstanceId); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityId); + Either<ImmutablePair<CapabilityInstData, GraphEdge>, TitanOperationStatus> getCapabilityInstancesRes = titanGenericDao.getChildByEdgeCriteria(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, + GraphEdgeLabels.CAPABILITY_INST, NodeTypeEnum.CapabilityInst, CapabilityInstData.class, props); + if (getCapabilityInstancesRes.isRight()) { + error = getCapabilityInstancesRes.right().value(); + log.debug("Failed to retrieve capability Instances of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error); + } + log.debug("After getting all capability instances ofRI {} statusIs {}.", resourceInstanceId, error); + if (error == null) { + log.debug("Before deleting all capability instances ofRI {}.", resourceInstanceId); + capabilityInstance = getCapabilityInstancesRes.left().value().getLeft(); + capabilityInstanceId = capabilityInstance.getUniqueId(); + deleteProperyValuesRes = deleteAllPropertyValuesOfCapabilityInstance(resourceInstanceId, capabilityInstanceId); + if (deleteProperyValuesRes.isRight()) { + error = deleteProperyValuesRes.right().value(); + log.debug("failedDeletePropertyValues {} forRI {} statusIs {}", capabilityInstanceId, resourceInstanceId, statusIs, error); + } + log.debug("After deleting all capability instances ofRI {} statusIs {}.", resourceInstanceId, error); + } + if (error == null) { + log.debug("Before getting capability {} ofRI {}.", capabilityId, resourceInstanceId); + getCapabilityDataRes = titanGenericDao.getChild(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.ResourceInstance), resourceInstanceId, GraphEdgeLabels.CALCULATED_CAPABILITY, NodeTypeEnum.Capability, CapabilityData.class); + if (getCapabilityDataRes.isRight()) { + error = getCapabilityDataRes.right().value(); + log.debug("Failed to get capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error); + } + log.debug("After getting capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error); + } + if (error == null) { + log.debug("Before getting capability definition for capability {} ofRI {}.", capabilityId, resourceInstanceId); + overrideCapabilityData = getCapabilityDataRes.left().value().getLeft(); + getCapabilityDefinitionRes = capabilityOperation.getCapabilityByCapabilityData(overrideCapabilityData); + if (getCapabilityDefinitionRes.isRight()) { + error = getCapabilityDefinitionRes.right().value(); + log.debug("Failed to retrieve capability {} ofRI {} statusIs {}", capabilityId, resourceInstanceId, error); + } + log.debug("After getting capability definition for capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error); + } + if (error == null) { + log.debug("Before validating capability properties of capability instance {} ofRI {}.", capabilityInstanceId, resourceInstanceId); + overrideCapabilityDefinition = getCapabilityDefinitionRes.left().value(); + if (overrideCapabilityDefinition.getProperties() != null) { + defaultProperties = overrideCapabilityDefinition.getProperties().stream().collect(Collectors.toMap(PropertyDefinition::getName, Function.identity())); + } + Either<Boolean, TitanOperationStatus> result = validateCapabilityInstanceProperties(defaultProperties, propertyValues); + if (result.isRight()) { + error = result.right().value(); + log.debug("failedAddProperties {} ofRI {} statusIs {}.", capabilityInstance.getUniqueId(), resourceInstanceId, error); + } + log.debug("After validating capability properties of capability instance {} of RI {} statusIs {}.", capabilityInstanceId, resourceInstanceId, error); + } + if (error == null) { + log.debug("Before adding property values toCI {} ofRI {}.", capabilityInstanceId, resourceInstanceId); + addPropertyValuesRes = addPropertyValuesToCapabilityInstance(capabilityInstance, propertyValues, defaultProperties); + if (addPropertyValuesRes.isRight()) { + error = addPropertyValuesRes.right().value(); + log.debug("failedAddProperties {} ofRI {} statusIs {}.", capabilityInstance.getUniqueId(), resourceInstanceId, error); + } + log.debug("Before adding property values toCI {} ofRI {}.", capabilityInstanceId, resourceInstanceId); + } + log.debug("After updating property values of capability {} ofRI {} statusIs {}.", capabilityId, resourceInstanceId, error); + if (error == null) { + return addPropertyValuesRes; + } + return Either.right(error); + } + + /** + * clone and associate capability instance with property values + * + * @param createdComponentInstance + * @param capability + * @param capabilityInstPair + * @return + */ + @Override + public Either<ImmutablePair<CapabilityInstData, List<PropertyValueData>>, TitanOperationStatus> cloneAssociateCapabilityInstanceWithPropertyValues(ComponentInstanceData createdComponentInstance, CapabilityDefinition capability, + ImmutablePair<CapabilityInstData, GraphEdge> capabilityInstPair) { + + TitanOperationStatus error = null; + String componentInstanceId = createdComponentInstance.getUniqueId(); + String capabilityInstanceId = capabilityInstPair.getLeft().getUniqueId(); + + log.debug("Before cloning capability instance with property values of capability instance {} ofRI {}.", capabilityInstanceId, componentInstanceId); + List<ImmutablePair<PropertyValueData, GraphEdge>> propertyValuePairs; + List<PropertyValueData> newPropertyValues = new ArrayList<>(); + CapabilityInstData cloneCapabilityInstance = null; + Either<CapabilityInstData, TitanOperationStatus> cloneCapabilityInstanceNodeRes = null; + + log.debug("Before getting all property values ofCI {} ofRI {}.", capabilityInstanceId, componentInstanceId); + Either<List<ImmutablePair<PropertyValueData, GraphEdge>>, TitanOperationStatus> getPropertyValuesRes = titanGenericDao.getChildrenNodes(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstPair.getLeft().getUniqueId(), + GraphEdgeLabels.PROPERTY_VALUE, NodeTypeEnum.PropertyValue, PropertyValueData.class); + if (getPropertyValuesRes.isRight()) { + error = getPropertyValuesRes.right().value(); + log.debug("Failed to retrieve property values of capability instance {} ofCI {} statusIs {}.", capabilityInstPair.getLeft().getUniqueId(), componentInstanceId ,error); + } + log.debug("After getting all property values ofCI {} ofRI {} statusIs {}.", capabilityInstanceId, componentInstanceId, error); + if (error == null) { + CapabilityInstData cloneCapabilityInst = buildCapabilityInstanceData(componentInstanceId, capability); + log.debug("Before creating capability instance node {} onGraph.", cloneCapabilityInst.getUniqueId()); + cloneCapabilityInstanceNodeRes = titanGenericDao.createNode(cloneCapabilityInst, CapabilityInstData.class); + if (cloneCapabilityInstanceNodeRes.isRight()) { + error = cloneCapabilityInstanceNodeRes.right().value(); + log.debug("Failed to create capability instance of capability {} ofCI {} statusIs {}.", capability.getUniqueId(), componentInstanceId, error); + } + log.debug("After creating capability instance node {} onGraph. statusIs {}", cloneCapabilityInst.getUniqueId(), error); + } + + if (error == null) { + log.debug("Before creating relation from capability instance {} toCapability {} onGraph.", cloneCapabilityInstanceNodeRes.left().value().getUniqueId(), capability.getUniqueId()); + cloneCapabilityInstance = cloneCapabilityInstanceNodeRes.left().value(); + CapabilityData capabilityData = buildCapabilityData(capability); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityData.getUniqueId()); + Either<GraphRelation, TitanOperationStatus> createRelationRes = titanGenericDao.createRelation(cloneCapabilityInstance, capabilityData, GraphEdgeLabels.INSTANCE_OF, props); + if (createRelationRes.isRight()) { + error = createRelationRes.right().value(); + log.debug("Failed to associate capability instance {} toCapability {} statusIs {}.", cloneCapabilityInstance.getUniqueId(), capability.getUniqueId(), error); + } + log.debug("After creating relation from capability instance {} toCapability {} onGraph. statusIs {}.", cloneCapabilityInstanceNodeRes.left().value().getUniqueId(), capability.getUniqueId(), error); + } + + if (error == null) { + log.debug("Before cloning property values ofCI {}.", capabilityInstanceId); + propertyValuePairs = getPropertyValuesRes.left().value(); + for (ImmutablePair<PropertyValueData, GraphEdge> propertyValuePair : propertyValuePairs) { + Either<PropertyValueData, TitanOperationStatus> clonePropertyValueRes = cloneAssociatePropertyValue(cloneCapabilityInstance, propertyValuePair); + if (clonePropertyValueRes.isRight()) { + error = clonePropertyValueRes.right().value(); + if (log.isDebugEnabled()) { + log.debug("Failed to clone property value {} ofCapability {} ofCI {}. statusIs {}.", propertyValuePair.getLeft().getUniqueId(), capability.getUniqueId(), componentInstanceId, error); + } + break; + } else { + newPropertyValues.add(clonePropertyValueRes.left().value()); + } + } + log.debug("After cloning property values of CI {} statusIs {}.", capabilityInstanceId, error); + } + log.debug("After cloning capability instance with property values of capability instance {} ofRI {} statusIs {}.", capabilityInstanceId, componentInstanceId, error); + if (error == null) { + return Either.left(new ImmutablePair<CapabilityInstData, List<PropertyValueData>>(cloneCapabilityInstance, newPropertyValues)); + } + return Either.right(error); + } + + public Either<TitanVertex, TitanOperationStatus> cloneAssociateCapabilityInstanceWithPropertyValues(TitanVertex componentInstanceVertex, CapabilityDefinition capability, ImmutablePair<CapabilityInstData, GraphEdge> capabilityInstPair) { + + TitanOperationStatus error = null; + String componentInstanceId = (String) titanGenericDao.getProperty(componentInstanceVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + String capabilityInstanceId = capabilityInstPair.getLeft().getUniqueId(); + + if (log.isTraceEnabled()) { + log.trace("Before cloning capability instance with property values of capability instance {} {} {}", capabilityInstanceId, ofRI, componentInstanceId); + } + List<ImmutablePair<TitanVertex, Edge>> propertyValuePairs; + Either<TitanVertex, TitanOperationStatus> cloneCapabilityInstanceNodeRes = null; + + if (log.isTraceEnabled()) { + log.trace("Before getting all property values {} {} {} {}", ofCI, capabilityInstanceId, ofRI, componentInstanceId); + } + Either<List<ImmutablePair<TitanVertex, Edge>>, TitanOperationStatus> getPropertyValuesRes = titanGenericDao.getChildrenVertecies(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.CapabilityInst), capabilityInstPair.getLeft().getUniqueId(), + GraphEdgeLabels.PROPERTY_VALUE); + if (getPropertyValuesRes.isRight()) { + error = getPropertyValuesRes.right().value(); + if (log.isDebugEnabled()) { + log.debug("Failed to retrieve property values of capability instance {} {} {} {} {}", capabilityInstPair.getLeft().getUniqueId(), ofCI, componentInstanceId, statusIs, error); + } + } + if (log.isTraceEnabled()) { + log.trace("After getting all property values {} {} {} {} {} {}", ofCI, capabilityInstanceId, ofRI, componentInstanceId, statusIs, error); + } + if (error == null) { + CapabilityInstData cloneCapabilityInst = buildCapabilityInstanceData(componentInstanceId, capability); + log.trace("Before creating capability instance node {} {} ", cloneCapabilityInst.getUniqueId(), onGraph); + cloneCapabilityInstanceNodeRes = titanGenericDao.createNode(cloneCapabilityInst); + if (cloneCapabilityInstanceNodeRes.isRight()) { + error = cloneCapabilityInstanceNodeRes.right().value(); + if (log.isDebugEnabled()) { + log.debug("Failed to create capability instance of capability {} {} {} {} {}", capability.getUniqueId(), ofCI, componentInstanceId, statusIs, error); + } + } + if (log.isTraceEnabled()) { + log.trace("After creating capability instance node {} {} {} {}", cloneCapabilityInst.getUniqueId(), onGraph, statusIs, error); + } + } + CapabilityData capabilityData; + TitanVertex cloneCapabilityInstance = null; + if (error == null) { + if (log.isTraceEnabled()) { + log.trace("Before creating relation from capability instance {} {} {} {}", capability.getUniqueId(), toCapability, capability.getUniqueId(), onGraph); + } + capabilityData = buildCapabilityData(capability); + Map<String, Object> props = new HashMap<>(); + props.put(GraphPropertiesDictionary.CAPABILITY_ID.getProperty(), capabilityData.getUniqueId()); + cloneCapabilityInstance = cloneCapabilityInstanceNodeRes.left().value(); + TitanOperationStatus createRelationRes = titanGenericDao.createEdge(cloneCapabilityInstance, capabilityData, GraphEdgeLabels.INSTANCE_OF, props); + if (!createRelationRes.equals(TitanOperationStatus.OK)) { + error = createRelationRes; + if (log.isDebugEnabled()) { + log.debug("Failed to associate capability instance {} {} {} {} {}", capabilityData.getUniqueId(), toCapability, capability.getUniqueId(), statusIs, createRelationRes); + } + } + if (log.isTraceEnabled()) { + log.trace("After creating relation from capability instance {} {} {} {} {} {}", capabilityData.getUniqueId(), toCapability, capability.getUniqueId(), onGraph, statusIs, error); + } + } + + if (error == null) { + log.trace("Before cloning property values {} {} ", ofCI, capabilityInstanceId); + propertyValuePairs = getPropertyValuesRes.left().value(); + for (ImmutablePair<TitanVertex, Edge> propertyValuePair : propertyValuePairs) { + TitanOperationStatus clonePropertyValueRes = cloneAssociatePropertyValue(cloneCapabilityInstance, propertyValuePair); + if (!clonePropertyValueRes.equals(TitanOperationStatus.OK)) { + error = clonePropertyValueRes; + if (log.isDebugEnabled()) { + log.debug("Failed to clone property value of capability {} {} {} {} {}", capability.getUniqueId(), ofCI, componentInstanceId, statusIs, error); + } + break; + } + } + if (log.isDebugEnabled()) { + log.debug("After cloning property values {} {} {} {}", ofCI, capabilityInstanceId, statusIs, error); + } + } + log.debug("After cloning capability instance with property values of capability instance {} ofRI {} statusIs {}.", capabilityInstanceId, componentInstanceId, error); + if (error == null) { + return Either.left(cloneCapabilityInstance); + } + return Either.right(error); + } + + private CapabilityData buildCapabilityData(CapabilityDefinition capability) { + CapabilityData capabilityData = new CapabilityData(); + capabilityData.setUniqueId(capability.getUniqueId()); + capabilityData.setDescription(capability.getDescription()); + capabilityData.setType(capability.getType()); + capabilityData.setMaxOccurrences(capability.getMaxOccurrences()); + capabilityData.setMinOccurrences(capability.getMinOccurrences()); + List<String> validSourceTypes = capability.getValidSourceTypes(); + if (validSourceTypes != null) { + capabilityData.setValidSourceTypes(validSourceTypes); + } + return capabilityData; + } + + private Either<PropertyValueData, TitanOperationStatus> cloneAssociatePropertyValue(CapabilityInstData cloneCapabilityInstance, ImmutablePair<PropertyValueData, GraphEdge> propertyValuePair) { + TitanOperationStatus error = null; + String propertyValueID = propertyValuePair.getLeft().getUniqueId(); + String capabilityInstanceId = cloneCapabilityInstance.getUniqueId(); + log.debug("Before cloning property values {} ofCI {}.", propertyValueID, capabilityInstanceId); + + Map<String, Object> props = propertyValuePair.getRight().getProperties(); + PropertyData propertyData = new PropertyData(); + String propertyId = (String) props.get(GraphPropertiesDictionary.PROPERTY_ID.name()); + propertyData.getPropertyDataDefinition().setUniqueId(propertyId); + + PropertyValueData propertyValue = buildPropertyValueData((String) props.get(GraphPropertiesDictionary.PROPERTY_NAME.name()), propertyValuePair.getLeft().getType(), propertyValuePair.getLeft().getValue(), capabilityInstanceId); + PropertyValueData createdValue = null; + Either<GraphRelation, TitanOperationStatus> createRelationRes; + + log.debug("Before creating property values node {} onGraph.", propertyValue.getUniqueId()); + Either<PropertyValueData, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue, PropertyValueData.class); + if (createValueRes.isRight()) { + error = createValueRes.right().value(); + log.debug("Failed to create property value for capability instance {} ofRI. statusIs {}.", cloneCapabilityInstance.getUniqueId(), error); + } + log.debug("After creating property values node {} onGraph. statusIs {}.", propertyValue.getUniqueId(), error); + if (error == null) { + createdValue = createValueRes.left().value(); + log.debug("Before creating relation from capability instance {} toValue {}.", capabilityInstanceId, createdValue.getUniqueId()); + createRelationRes = titanGenericDao.createRelation(cloneCapabilityInstance, createdValue, GraphEdgeLabels.PROPERTY_VALUE, props); + if (createRelationRes.isRight()) { + error = createRelationRes.right().value(); + log.debug("Failed to create relation from capability instance {} toValue {} statusIs {}.", cloneCapabilityInstance.getUniqueId(), createdValue.getUniqueId(), error); + } + log.debug("After creating relation from capability instance {} toValue {} statusIs {}", capabilityInstanceId, createdValue.getUniqueId(), error); + } + if (error == null) { + log.debug("Before creating relation from property value {} toProperty {}.", createdValue, propertyData.getUniqueId()); + createRelationRes = titanGenericDao.createRelation(createdValue, propertyData, GraphEdgeLabels.PROPERTY_IMPL, props); + if (createRelationRes.isRight()) { + error = createRelationRes.right().value(); + log.debug("Failed to create relation from property value {} toProperty {} statusIs {}.", createdValue.getUniqueId(), propertyId, error); + } + log.debug("Before creating relation from property value {} toProperty {} statusIs {}.", createdValue, propertyData.getUniqueId(), error); + } + log.debug("After cloning property values {} ofCI {} statusIs {}.", propertyValueID, capabilityInstanceId, error); + if (error == null) { + return Either.left(createdValue); + } + return Either.right(error); + } + + private TitanOperationStatus cloneAssociatePropertyValue(TitanVertex capabilityInstanceVertex, ImmutablePair<TitanVertex, Edge> propertyValuePair) { + TitanOperationStatus error = null; + TitanVertex propertyVertex = propertyValuePair.getLeft(); + String propertyValueID = (String) titanGenericDao.getProperty(propertyVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + String capabilityInstanceId = (String) titanGenericDao.getProperty(capabilityInstanceVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + if (log.isTraceEnabled()) { + log.trace("Before cloning property values {} {} {}", propertyValueID, ofCI, capabilityInstanceId); + } + + Map<String, Object> props = titanGenericDao.getProperties(propertyValuePair.getRight()); + PropertyData propertyData = new PropertyData(); + String propertyId = (String) props.get(GraphPropertiesDictionary.PROPERTY_ID.name()); + propertyData.getPropertyDataDefinition().setUniqueId(propertyId); + + String propertyType = (String) titanGenericDao.getProperty(propertyVertex, GraphPropertiesDictionary.TYPE.getProperty()); + String propertyValueStr = (String) titanGenericDao.getProperty(propertyVertex, GraphPropertiesDictionary.VALUE.getProperty()); + + PropertyValueData propertyValue = buildPropertyValueData((String) props.get(GraphPropertiesDictionary.PROPERTY_NAME.name()), propertyType, propertyValueStr, capabilityInstanceId); + TitanVertex createdValue = null; + TitanOperationStatus createRelationRes; + + log.trace("Before creating property values node {} {} ", propertyValue.getUniqueId(), onGraph); + Either<TitanVertex, TitanOperationStatus> createValueRes = titanGenericDao.createNode(propertyValue); + String capabiltyInstId = (String) titanGenericDao.getProperty(capabilityInstanceVertex, GraphPropertiesDictionary.UNIQUE_ID.getProperty()); + if (createValueRes.isRight()) { + error = createValueRes.right().value(); + if (log.isDebugEnabled()) { + log.debug("Failed to create property value for capability instance {} {} {} {}", capabiltyInstId, ofRI, statusIs, error); + } + } + if (log.isTraceEnabled()) { + log.trace("After creating property values node {} {} {} {} ", propertyValue.getUniqueId(), onGraph, statusIs, error); + } + if (error == null) { + createdValue = createValueRes.left().value(); + log.trace("Before creating relation from capability instance {} {} {}", capabilityInstanceId, toValue, propertyValue.getUniqueId()); + createRelationRes = titanGenericDao.createEdge(capabilityInstanceVertex, createdValue, GraphEdgeLabels.PROPERTY_VALUE, props); + if (!createRelationRes.equals(TitanOperationStatus.OK)) { + error = createRelationRes; + if (log.isDebugEnabled()) { + log.debug("Failed to create relation from capability instance {} {} {} {} {}", capabiltyInstId, toValue, propertyValue.getUniqueId(), statusIs, error); + } + } + if (log.isTraceEnabled()) { + log.trace("After creating relation from capability instance {} {} {} {} {} ", capabilityInstanceId, toValue, propertyValue.getUniqueId(), statusIs, error); + } + } + if (error == null) { + log.trace("Before creating relation from property value {} {} {} ", createdValue, toProperty, propertyData.getUniqueId()); + createRelationRes = titanGenericDao.createEdge(createdValue, propertyData, GraphEdgeLabels.PROPERTY_IMPL, props); + if (!createRelationRes.equals(TitanOperationStatus.OK)) { + error = createRelationRes; + if (log.isDebugEnabled()) { + log.debug("Failed to create relation from property value {} {} {} {} {}", propertyValue.getUniqueId(), toProperty, propertyId, statusIs, error); + } + } + if (log.isTraceEnabled()) { + log.trace("Before creating relation from property value c", createdValue, toProperty, propertyData.getUniqueId(), statusIs, error); + } + } + if (log.isTraceEnabled()) { + log.trace("After cloning property values {} {} {} {} {}", propertyValueID, ofCI, capabilityInstanceId, statusIs, error); + } + if (error == null) { + return TitanOperationStatus.OK; + } + return error; + } +} |