* 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.
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-
package org.openecomp.sdc.be.model.jsonjanusgraph.utils;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
+import java.util.UUID;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;
-import org.apache.commons.lang.BooleanUtils;
+import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionaryExtractor;
+import org.openecomp.sdc.be.datatypes.category.MetadataKeyDataDefinition;
import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.MapAttributesDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.ProductMetadataDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.AttributeDefinition;
import org.openecomp.sdc.be.model.CapabilityDefinition;
import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
import org.openecomp.sdc.be.model.ComponentInstanceInput;
import org.openecomp.sdc.be.model.ComponentInstanceInterface;
+import org.openecomp.sdc.be.model.ComponentInstanceOutput;
import org.openecomp.sdc.be.model.ComponentInstanceProperty;
import org.openecomp.sdc.be.model.DataTypeDefinition;
import org.openecomp.sdc.be.model.DistributionStatusEnum;
import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.openecomp.sdc.be.model.MapInterfaceInstanceDataDefinition;
+import org.openecomp.sdc.be.model.OutputDefinition;
import org.openecomp.sdc.be.model.PolicyDefinition;
import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.RelationshipImpl;
import org.openecomp.sdc.be.model.RequirementDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
import org.openecomp.sdc.be.model.operations.StorageException;
import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
import org.openecomp.sdc.be.resources.data.ProductMetadataData;
import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
+import org.openecomp.sdc.be.ui.model.OperationUi;
+import org.openecomp.sdc.be.ui.model.PropertyAssignmentUi;
import org.openecomp.sdc.common.log.wrappers.Logger;
public class ModelConverter {
+
public static final String CAP_PROP_DELIM = "#";
private static final Logger log = Logger.getLogger(ModelConverter.class);
+ private ModelConverter() {
+ }
+
@SuppressWarnings("unchecked")
public static <T extends ToscaElement> T convertToToscaElement(Component component) {
if (isAtomicComponent(component)) {
@SuppressWarnings("unchecked")
public static <T extends Component> T convertFromToscaElement(ToscaElement toscaElement) {
switch (toscaElement.getComponentType()) {
- case RESOURCE:
- return (T) convertToResource(toscaElement);
- case SERVICE:
- case PRODUCT:
- return (T) convertToService(toscaElement);
- default:
- return null;
+ case RESOURCE:
+ return (T) convertToResource(toscaElement);
+ case SERVICE:
+ case PRODUCT:
+ return (T) convertToService(toscaElement);
+ default:
+ return null;
}
}
}
public static VertexTypeEnum getVertexType(String resourceTypeName) {
- VertexTypeEnum vertexType = null;
ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName);
if (isAtomicComponent(resourceType)) {
- vertexType = VertexTypeEnum.NODE_TYPE;
+ return VertexTypeEnum.NODE_TYPE;
} else {
- vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
+ return VertexTypeEnum.TOPOLOGY_TEMPLATE;
}
- return vertexType;
}
-
-
- private static Service convertToService(ToscaElement toscaElement) {
- Service service = new Service();
- convertComponentFields(service, toscaElement);
-
+ private static Service convertToService(ToscaElement toscaElement) {
+ Service service = new Service();
+ convertComponentFields(service, toscaElement);
convertServiceSpecificFields(toscaElement, service);
-
TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
-
convertComponentInstances(topologyTemplate, service);
-
- convertInputs(topologyTemplate, service);
-
- convertProperties(topologyTemplate, service);
-
- convertPolicies(topologyTemplate, service);
-
- convertProperties(topologyTemplate, service);
-
- convertPolicies(topologyTemplate, service);
-
+ convertInputs(topologyTemplate, service);
+ convertOutputs(topologyTemplate, service);
+ convertProperties(topologyTemplate, service);
+ convertPolicies(topologyTemplate, service);
+ convertAttributesToComponent(topologyTemplate, service);
convertGroups(topologyTemplate, service);
-
- setCapabilitiesToComponentAndGroups(topologyTemplate, service);
-
+ setCapabilitiesToComponentAndGroups(topologyTemplate, service);
convertPolicies(topologyTemplate, service);
-
convertRelations(topologyTemplate, service);
-
convertArtifacts(topologyTemplate, service);
-
convertServiceApiArtifacts(topologyTemplate, service);
-
convertServicePaths(topologyTemplate, service);
-
convertServiceInterfaces(topologyTemplate, service);
-
convertDataTypes(topologyTemplate, service);
-
convertNodeFiltersComponents(topologyTemplate, service);
+ convertSubstitutionFiltersComponents(topologyTemplate, service);
setCapabilitiesToComponent(topologyTemplate, service);
setRequirementsToComponent(topologyTemplate, service);
return service;
}
- private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) {
- service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE));
- service.setDistributionStatus(DistributionStatusEnum
- .findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
- service.setEcompGeneratedNaming(
- (Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
- service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY,
- StringUtils.EMPTY));
- service.setEnvironmentContext(
- (String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT));
- service.setInstantiationType((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.INSTANTIATION_TYPE, StringUtils.EMPTY));
- }
+ private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) {
+ service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE));
+ service.setDistributionStatus(
+ DistributionStatusEnum.findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
+ service.setEcompGeneratedNaming((Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
+ service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, StringUtils.EMPTY));
+ service.setEnvironmentContext((String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT));
+ service.setInstantiationType((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.INSTANTIATION_TYPE, StringUtils.EMPTY));
+ }
private static Resource convertToResource(ToscaElement toscaElement) {
Resource resource = new Resource();
convertComponentFields(resource, toscaElement);
-
resource.setResourceType(toscaElement.getResourceType());
if (toscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) {
NodeType nodeType = (NodeType) toscaElement;
resource.setDerivedList(nodeType.getDerivedList());
resource.setDerivedFromMapOfIdToName(nodeType.getDerivedFromMapOfIdToName());
resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
- convertAttributes(nodeType, resource);
+ final String toscaVersion = nodeType.getToscaVersion();
+ if (toscaVersion != null) {
+ resource.setToscaVersion(toscaVersion);
+ }
+ convertAttributesToResource(nodeType, resource);
convertCapabilities(nodeType, resource);
convertRequirements(nodeType, resource);
convertInterfaces(nodeType, resource);
-
- } else {
- TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
- if (resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.PNF) {
- resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
- resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
- resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
+ convertDataTypes(nodeType, resource);
+ } else {
+ TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
+ if (resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.PNF) {
+ resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
+ resource.setCsarVersionId((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION_ID));
+ resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
+ resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
convertInterfaces(topologyTemplate, resource);
}
convertComponentInstances(topologyTemplate, resource);
convertRelations(topologyTemplate, resource);
convertInputs(topologyTemplate, resource);
+ convertOutputs(topologyTemplate, resource);
convertGroups(topologyTemplate, resource);
- setCapabilitiesToComponentAndGroups(topologyTemplate, resource);
+ setCapabilitiesToComponentAndGroups(topologyTemplate, resource);
convertPolicies(topologyTemplate, resource);
convertNodeFiltersComponents(topologyTemplate, resource);
+ convertSubstitutionFiltersComponents(topologyTemplate, resource);
convertProperties(topologyTemplate, resource);
+ convertAttributesToComponent(topologyTemplate, resource);
setCapabilitiesToComponent(topologyTemplate, resource);
setRequirementsToComponent(topologyTemplate, resource);
convertDataTypes(topologyTemplate, resource);
}
convertArtifacts(toscaElement, resource);
convertAdditionalInformation(toscaElement, resource);
-
return resource;
- }
+ }
private static void convertInterfaces(TopologyTemplate toscaElement, Resource resource) {
Map<String, InterfaceDataDefinition> interfaces = toscaElement.getInterfaces();
service.setInterfaces(copy);
}
- private static void convertAttributes(NodeType nodeType, Resource resource) {
- Map<String, PropertyDataDefinition> attributes = nodeType.getAttributes();
+ private static void convertAttributesToResource(NodeType nodeType, Resource resource) {
+ Map<String, AttributeDataDefinition> attributes = nodeType.getAttributes();
if (attributes != null) {
- List<PropertyDefinition> attrs = attributes.values().stream().map(dataDef -> ModelConverter.fromDataDefinition(resource.getUniqueId(), dataDef)).collect(Collectors.toList());
- resource.setAttributes(attrs);
+ final Map<String, AttributeDefinition> attributeDefinitionMap = attributes.entrySet().stream()
+ .collect(Collectors.toMap(Entry::getKey, o -> new AttributeDefinition(o.getValue())));
+ resource.setAttributes(new ArrayList<>(attributeDefinitionMap.values()));
}
}
- private static PropertyDefinition fromDataDefinition(String resourceId, PropertyDataDefinition dataDefinition) {
- PropertyDefinition attributeDefinition = new PropertyDefinition(dataDefinition);
- attributeDefinition.setParentUniqueId(resourceId);
- return attributeDefinition;
- }
-
private static void convertInterfaces(NodeType nodeType, Resource resource) {
Map<String, InterfaceDataDefinition> interfaceArtifacts = nodeType.getInterfaceArtifacts();
if (interfaceArtifacts != null) {
- Map<String, InterfaceDefinition> interfaces = interfaceArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue())));
+ Map<String, InterfaceDefinition> interfaces = interfaceArtifacts.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue())));
resource.setInterfaces(interfaces);
}
}
* @param component
*/
public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) {
-
if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) {
-
setComponentInstancesAttributesToComponent(topologyTemplate, component);
-
setComponentInstancesPropertiesToComponent(topologyTemplate, component);
-
setComponentInstancesInputsToComponent(topologyTemplate, component);
-
+ setComponentInstancesOutputsToComponent(topologyTemplate, component);
setComponentInstancesToComponent(topologyTemplate, component);
-
setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component);
-
setComponentInstancesRequirementsToComponent(topologyTemplate, component);
-
setComponentInstancesArtifactsToComponent(topologyTemplate, component);
-
setComponentInstancesInterfacesToComponent(topologyTemplate, component);
-
}
}
private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) {
Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts();
Map<String, MapArtifactDataDefinition> instanceArtifacts = topologyTemplate.getInstanceArtifacts();
-
setComponentInstancesDeploymentArtifactsToComponent(instDeploymentArtifacts, component);
setComponentInstancesInformationalArtifactsToComponent(instanceArtifacts, component);
-
}
- public static void setComponentInstancesInformationalArtifactsToComponent(Map<String, MapArtifactDataDefinition> instanceArtifacts, Component component) {
+ public static void setComponentInstancesInformationalArtifactsToComponent(Map<String, MapArtifactDataDefinition> instanceArtifacts,
+ Component component) {
List<ComponentInstance> instances = component.getComponentInstances();
if (instanceArtifacts != null && instances != null) {
instanceArtifacts.entrySet().forEach(e -> {
Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
if (ci.isPresent()) {
Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
- Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
-
+ Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
ci.get().setArtifacts(deplArt);
}
});
}
}
- public static void setComponentInstancesDeploymentArtifactsToComponent(Map<String, MapArtifactDataDefinition> instDeploymentArtifacts, Component component) {
+ public static void setComponentInstancesDeploymentArtifactsToComponent(Map<String, MapArtifactDataDefinition> instDeploymentArtifacts,
+ Component component) {
List<ComponentInstance> instances = component.getComponentInstances();
if (instDeploymentArtifacts != null && instances != null) {
instDeploymentArtifacts.entrySet().forEach(e -> {
Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
if (ci.isPresent()) {
Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
- Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
-
+ Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
ci.get().setDeploymentArtifacts(deplArt);
}
});
}
public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) {
-
if (!CollectionUtils.isEmpty(component.getComponentInstances())) {
-
setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate);
-
setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate);
-
setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate);
-
setComponentInstancesToTopologyTemplate(component, topologyTemplate);
-
setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate);
}
}
List<RequirementCapabilityRelDef> componentRelations;
if (relations != null && !relations.isEmpty()) {
componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList());
-
} else {
componentRelations = new ArrayList<>();
}
component.setComponentInstancesRelations(componentRelations);
-
}
public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) {
requirementCapabilityRelDef.setFromNode(relation.getFromId());
requirementCapabilityRelDef.setToNode(relation.getToId());
requirementCapabilityRelDef.setOriginUI(BooleanUtils.isTrue(relation.isOriginUI()));
-
CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship();
RelationshipInfo relationshipPair = getRelationshipInfo(relation);
rel.setRelation(relationshipPair);
+ rel.setOperations(convertToOperations(relation.getInterfaces()));
requirementCapabilityRelDef.setRelationships(Arrays.asList(rel));
-
return requirementCapabilityRelDef;
}
+ private static List<OperationUi> convertToOperations(final ListDataDefinition<InterfaceDataDefinition> interfaces) {
+ if (interfaces == null || interfaces.isEmpty()) {
+ return Collections.emptyList();
+ }
+ final List<OperationUi> operationUiList = new ArrayList<>();
+ for (final InterfaceDataDefinition interfaceDataDefinition : interfaces.getListToscaDataDefinition()) {
+ if (MapUtils.isEmpty(interfaceDataDefinition.getOperations())) {
+ continue;
+ }
+ for (final Entry<String, OperationDataDefinition> operationEntry : interfaceDataDefinition.getOperations().entrySet()) {
+ final OperationUi operationUi = new OperationUi();
+ operationUi.setOperationType(operationEntry.getKey());
+ operationUi.setInterfaceType(interfaceDataDefinition.getType());
+ final OperationDataDefinition operationDataDefinition = operationEntry.getValue();
+ final ArtifactDataDefinition artifactDataDefinition = operationDataDefinition.getImplementation();
+ if (artifactDataDefinition != null) {
+ operationUi.setImplementation(artifactDataDefinition.getArtifactName());
+ }
+ final ListDataDefinition<OperationInputDefinition> inputs = operationDataDefinition.getInputs();
+ if (inputs != null && !inputs.isEmpty()) {
+ final List<OperationInputDefinition> operationInputDefinitionList = inputs.getListToscaDataDefinition();
+ operationInputDefinitionList.forEach(operationInputDefinition -> {
+ final PropertyAssignmentUi propertyAssignmentUi = new PropertyAssignmentUi();
+ propertyAssignmentUi.setName(operationInputDefinition.getLabel());
+ propertyAssignmentUi.setType(operationInputDefinition.getType());
+ propertyAssignmentUi.setValue(operationInputDefinition.getValue());
+ operationUi.addToInputs(propertyAssignmentUi);
+ });
+ }
+ operationUiList.add(operationUi);
+ }
+ }
+ return operationUiList;
+ }
+
/**
* @param relation
* @return
*/
private static RelationshipInfo getRelationshipInfo(RelationshipInstDataDefinition relation) {
RelationshipInfo relationshipPair = new RelationshipInfo();
-
relationshipPair.setId(relation.getUniqueId());
-
relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
relationshipPair.setCapabilityUid(relation.getCapabilityId());
relationshipPair.setCapability(relation.getCapability());
-
relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
relationshipPair.setRequirementUid(relation.getRequirementId());
relationshipPair.setRequirement(relation.getRequirement());
-
RelationshipImpl relationship = new RelationshipImpl();
relationship.setType(relation.getType());
relationshipPair.setRelationships(relationship);
-
return relationshipPair;
}
-
public static List<RelationshipInstDataDefinition> convertRelationToToscaRelation(RequirementCapabilityRelDef relation) {
-
List<RelationshipInstDataDefinition> relationsList = new ArrayList<>();
-
List<CapabilityRequirementRelationship> relationship = relation.getRelationships();
relationship.forEach(p -> {
RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition();
requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType());
requirementCapabilityRelDef.setCapability(p.getRelation().getCapability());
requirementCapabilityRelDef.setOriginUI(relation.isOriginUI());
+ createRelationshipInterfaces(p.getOperations()).ifPresent(requirementCapabilityRelDef::setInterfaces);
relationsList.add(requirementCapabilityRelDef);
});
-
return relationsList;
}
+ private static Optional<ListDataDefinition<InterfaceDataDefinition>> createRelationshipInterfaces(final List<OperationUi> operationList) {
+ if (CollectionUtils.isEmpty(operationList)) {
+ return Optional.empty();
+ }
+ final ListDataDefinition<InterfaceDataDefinition> interfaceList = new ListDataDefinition<>();
+ final Map<String, List<OperationUi>> operationByInterfaceType = operationList.stream()
+ .collect(Collectors.groupingBy(OperationUi::getInterfaceType));
+ for (final Entry<String, List<OperationUi>> interfaceEntry : operationByInterfaceType.entrySet()) {
+ interfaceList.add(createInterface(interfaceEntry.getKey(), interfaceEntry.getValue()));
+ }
+ return Optional.of(interfaceList);
+ }
+
+ private static InterfaceDataDefinition createInterface(final String interfaceType, final List<OperationUi> operationList) {
+ final InterfaceDataDefinition interfaceDataDefinition = new InterfaceDataDefinition();
+ interfaceDataDefinition.setType(interfaceType);
+ if (CollectionUtils.isNotEmpty(operationList)) {
+ final Map<String, OperationDataDefinition> operationMap = operationList.stream()
+ .collect(Collectors.toMap(OperationUi::getOperationType, ModelConverter::createOperation));
+ interfaceDataDefinition.setOperations(operationMap);
+ }
+ return interfaceDataDefinition;
+ }
+
+ private static OperationDataDefinition createOperation(final OperationUi operation) {
+ final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
+ operationDataDefinition.setName(operation.getOperationType());
+ operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
+ final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
+ artifactDataDefinition.setArtifactName((String) operation.getImplementation());
+ operationDataDefinition.setImplementation(artifactDataDefinition);
+ if (CollectionUtils.isNotEmpty(operation.getInputs())) {
+ final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
+ operation.getInputs().forEach(input -> {
+ final OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
+ operationInputDefinition.setLabel(input.getName());
+ operationInputDefinition.setType(input.getType());
+ operationInputDefinition.setValue(input.getValue());
+ inputs.add(operationInputDefinition);
+ });
+ operationDataDefinition.setInputs(inputs);
+ }
+ return operationDataDefinition;
+ }
+
private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) {
convertTopologyTemplateCapabilities(component, topologyTemplate);
- if(componentInstancesCapabilitiesExist(component) || groupsCapabilitiesExist(component)){
+ if (componentInstancesCapabilitiesExist(component) || groupsCapabilitiesExist(component)) {
topologyTemplate.setCalculatedCapabilities(new HashMap<>());
topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
}
}
private static void convertGroupsCapabilities(Component component, TopologyTemplate topologyTemplate) {
- if(groupsCapabilitiesExist(component)){
- component.getGroups()
- .stream()
- .filter(g -> MapUtils.isNotEmpty(g.getCapabilities()))
- .forEach(g -> addCapabilities(topologyTemplate, g.getCapabilities(), g.getUniqueId()));
+ if (groupsCapabilitiesExist(component)) {
+ component.getGroups().stream().filter(g -> MapUtils.isNotEmpty(g.getCapabilities()))
+ .forEach(g -> addCapabilities(topologyTemplate, g.getCapabilities(), g.getUniqueId()));
}
}
private static void convertTopologyTemplateCapabilities(Component component, ToscaElement toscaElement) {
Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
-
Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
-
- if (MapUtils.isNotEmpty(capabilities )) {
+ if (MapUtils.isNotEmpty(capabilities)) {
capabilities.forEach((s, caps) -> {
- if (CollectionUtils.isNotEmpty(caps)) {
- List<CapabilityDataDefinition> capList = caps.stream().filter(capabilityDefinition -> capabilityDefinition.getOwnerId()
- .equals(component.getUniqueId())).map(CapabilityDataDefinition::new).collect(Collectors.toList());
-
- populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
- }
- }
- );
-
+ if (CollectionUtils.isNotEmpty(caps)) {
+ List<CapabilityDataDefinition> capList = caps.stream()
+ .filter(capabilityDefinition -> capabilityDefinition.getOwnerId().equals(component.getUniqueId()))
+ .map(CapabilityDataDefinition::new).collect(Collectors.toList());
+ populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
+ }
+ });
toscaElement.setCapabilities(toscaCapMap);
toscaElement.setCapabilitiesProperties(toscaCapPropMap);
}
}
+
private static void populateCapabilityMap(Map<String, ListCapabilityDataDefinition> toscaCapMap,
- Map<String, MapPropertiesDataDefinition> toscaCapPropMap,
- String s, List<CapabilityDefinition> caps,
+ Map<String, MapPropertiesDataDefinition> toscaCapPropMap, String s, List<CapabilityDefinition> caps,
List<CapabilityDataDefinition> capList) {
ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList);
toscaCapMap.put(s, listCapabilityDataDefinition);
-
for (CapabilityDefinition cap : caps) {
List<ComponentInstanceProperty> capPrps = cap.getProperties();
if (CollectionUtils.isNotEmpty(capPrps)) {
private static void convertTopologyTemplateRequirements(Component component, ToscaElement toscaElement) {
Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
-
Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
-
- if (MapUtils.isNotEmpty(requirements )) {
- requirements.forEach((s, reqs)-> {
- if (CollectionUtils.isNotEmpty(reqs)) {
- List<RequirementDataDefinition> reqList = reqs.stream().filter(requirementDefinition -> requirementDefinition.getOwnerId()
- .equals(component.getUniqueId())).map(RequirementDataDefinition::new).collect(Collectors.toList());
-
- ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
- toscaReqMap.put(s, listRequirementDataDefinition);
- }
- }
- );
+ if (MapUtils.isNotEmpty(requirements)) {
+ requirements.forEach((s, reqs) -> {
+ if (CollectionUtils.isNotEmpty(reqs)) {
+ List<RequirementDataDefinition> reqList = reqs.stream()
+ .filter(requirementDefinition -> requirementDefinition.getOwnerId().equals(component.getUniqueId()))
+ .map(RequirementDataDefinition::new).collect(Collectors.toList());
+ ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
+ toscaReqMap.put(s, listRequirementDataDefinition);
+ }
+ });
toscaElement.setRequirements(toscaReqMap);
}
}
+
private static void convertComponentInstancesCapabilities(Component component, TopologyTemplate topologyTemplate) {
if (componentInstancesCapabilitiesExist(component)) {
- component.getComponentInstances()
- .stream()
- .filter(i -> MapUtils.isNotEmpty(i.getCapabilities()))
- .forEach(i -> addCapabilities(topologyTemplate, i.getCapabilities(), i.getUniqueId()));
+ component.getComponentInstances().stream().filter(i -> MapUtils.isNotEmpty(i.getCapabilities()))
+ .forEach(i -> addCapabilities(topologyTemplate, i.getCapabilities(), i.getUniqueId()));
}
}
}
private static boolean componentInstancesCapabilitiesExist(Component component) {
- return component.getCapabilities() != null && component.getComponentInstances() != null
- && component.getComponentInstances()
- .stream()
- .anyMatch(ci->MapUtils.isNotEmpty(ci.getCapabilities()));
+ return component.getCapabilities() != null && component.getComponentInstances() != null && component.getComponentInstances().stream()
+ .anyMatch(ci -> MapUtils.isNotEmpty(ci.getCapabilities()));
}
+
private static boolean groupsCapabilitiesExist(Component component) {
- return component.getCapabilities() != null && component.getGroups() != null
- && component.getGroups()
- .stream()
- .anyMatch(g->MapUtils.isNotEmpty(g.getCapabilities()));
+ return component.getCapabilities() != null && component.getGroups() != null && component.getGroups().stream()
+ .anyMatch(g -> MapUtils.isNotEmpty(g.getCapabilities()));
}
- public static MapCapabilityProperty convertToMapOfMapCapabilityProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId, boolean isAtomicType) {
-
+ public static MapCapabilityProperty convertToMapOfMapCapabilityProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId,
+ boolean isAtomicType) {
Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
- if(MapUtils.isNotEmpty(capabilities)){
- capabilities.forEach((s, caps)-> addCapsProperties(ownerId, isAtomicType, toscaCapPropMap, caps));
+ if (MapUtils.isNotEmpty(capabilities)) {
+ capabilities.forEach((s, caps) -> addCapsProperties(ownerId, isAtomicType, toscaCapPropMap, caps));
}
return new MapCapabilityProperty(toscaCapPropMap);
}
- private static void addCapsProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap, List<CapabilityDefinition> caps) {
+ private static void addCapsProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap,
+ List<CapabilityDefinition> caps) {
if (CollectionUtils.isNotEmpty(caps)) {
caps.forEach(cap -> addCapProperties(ownerId, isAtomicType, toscaCapPropMap, cap));
}
}
- private static void addCapProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap, CapabilityDefinition cap) {
+ private static void addCapProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap,
+ CapabilityDefinition cap) {
if (CollectionUtils.isNotEmpty(cap.getProperties())) {
- MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(cap.getProperties()
- .stream()
- .map(PropertyDataDefinition::new)
- .collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p)));
- toscaCapPropMap.put(buildCapabilityPropertyKey(isAtomicType, cap.getType(),cap.getName(),ownerId, cap),
- new MapPropertiesDataDefinition(dataToCreate));
+ MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(
+ cap.getProperties().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p)));
+ toscaCapPropMap.put(buildCapabilityPropertyKey(isAtomicType, cap.getType(), cap.getName(), ownerId, cap),
+ new MapPropertiesDataDefinition(dataToCreate));
}
}
- public static String buildCapabilityPropertyKey(boolean isAtomicType, String capabilityType, String capabilityName, String componentInstanceUniqueId, CapabilityDefinition cap) {
+ public static String buildCapabilityPropertyKey(boolean isAtomicType, String capabilityType, String capabilityName,
+ String componentInstanceUniqueId, CapabilityDefinition cap) {
StringBuilder sb = new StringBuilder(componentInstanceUniqueId);
- sb.append(CAP_PROP_DELIM)
- .append(cap.getOwnerId())
- .append(CAP_PROP_DELIM);
- if(!isAtomicType && !componentInstanceUniqueId.equals(cap.getOwnerId())){
- sb.append(cap.getOwnerId())
- .append(CAP_PROP_DELIM);
+ sb.append(CAP_PROP_DELIM).append(cap.getOwnerId()).append(CAP_PROP_DELIM);
+ if (!isAtomicType && !componentInstanceUniqueId.equals(cap.getOwnerId())) {
+ sb.append(cap.getOwnerId()).append(CAP_PROP_DELIM);
}
- return sb.append(capabilityType)
- .append(CAP_PROP_DELIM)
- .append(capabilityName).toString();
+ return sb.append(capabilityType).append(CAP_PROP_DELIM).append(capabilityName).toString();
}
- public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities, String ownerId) {
+ public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities,
+ String ownerId) {
return convertToMapOfMapCapabiltyProperties(instCapabilities, ownerId, false);
}
- public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId, boolean fromCsar) {
-
+ public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId,
+ boolean fromCsar) {
Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
- if(MapUtils.isNotEmpty(capabilities))
- capabilities.forEach((s, caps)-> {
-
- if (caps != null && !caps.isEmpty()) {
-
- MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
-
- for (CapabilityDefinition cap : caps) {
- List<ComponentInstanceProperty> capPrps = cap.getProperties();
- if (capPrps != null) {
-
- for (ComponentInstanceProperty cip : capPrps) {
- dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
- }
- // format key of capability properties :
- // VF instance in service : instanceId#ownerId#type#capName
- // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId
-
- StringBuilder sb = new StringBuilder(ownerId);
- sb.append(CAP_PROP_DELIM);
- if (fromCsar) {
- sb.append(ownerId);
- } else {
- sb.append(cap.getOwnerId());
- }
- sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
- toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate));
- }
- }
- }
- }
- );
+ if (MapUtils.isNotEmpty(capabilities)) {
+ capabilities.forEach((s, caps) -> {
+ if (caps != null && !caps.isEmpty()) {
+ MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
+ for (CapabilityDefinition cap : caps) {
+ List<ComponentInstanceProperty> capPrps = cap.getProperties();
+ if (capPrps != null) {
+ for (ComponentInstanceProperty cip : capPrps) {
+ dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
+ }
+ // format key of capability properties :
+
+ // VF instance in service : instanceId#ownerId#type#capName
+
+ // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId
+ StringBuilder sb = new StringBuilder(ownerId);
+ sb.append(CAP_PROP_DELIM);
+ if (fromCsar) {
+ sb.append(ownerId);
+ } else {
+ sb.append(cap.getOwnerId());
+ }
+ sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
+ toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate));
+ }
+ }
+ }
+ });
+ }
return new MapCapabilityProperty(toscaCapPropMap);
}
- private static MapListCapabilityDataDefinition convertToMapListCapabiltyDataDefinition(Map<String, List<CapabilityDefinition>> instCapabilities) {
-
+ private static MapListCapabilityDataDefinition convertToMapListCapabiltyDataDefinition(Map<String, List<CapabilityDefinition>> instCapabilities) {
Map<String, ListCapabilityDataDefinition> mapToscaDataDefinition = new HashMap<>();
for (Entry<String, List<CapabilityDefinition>> instCapability : instCapabilities.entrySet()) {
- mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList())));
+ mapToscaDataDefinition.put(instCapability.getKey(),
+ new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList())));
}
-
return new MapListCapabilityDataDefinition(mapToscaDataDefinition);
}
private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) {
-
convertTopologyTemplateRequirements(component, topologyTemplate);
if (component.getRequirements() != null && component.getComponentInstances() != null) {
topologyTemplate.setCalculatedRequirements(new HashMap<>());
if (topologyTemplate.getCalculatedRequirements() == null) {
topologyTemplate.setCalculatedRequirements(new HashMap<>());
}
- topologyTemplate.getCalculatedRequirements().put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements));
+ topologyTemplate.getCalculatedRequirements()
+ .put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements));
}
}
}
}
- private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(Map<String, List<RequirementDefinition>> instRequirements) {
-
+ private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(
+ Map<String, List<RequirementDefinition>> instRequirements) {
Map<String, ListRequirementDataDefinition> mapToscaDataDefinition = new HashMap<>();
for (Entry<String, List<RequirementDefinition>> instRequirement : instRequirements.entrySet()) {
- mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(instRequirement.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList())));
+ mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(
+ instRequirement.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList())));
}
-
return new MapListRequirementDataDefinition(mapToscaDataDefinition);
}
component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName());
component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId());
component.setNormalizedName(toscaElement.getNormalizedName());
-
component.setLifecycleState(toscaElement.getLifecycleState());
component.setVersion(toscaElement.getVersion());
component.setHighestVersion(toscaElement.isHighestVersion());
component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME));
component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType());
component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion());
-
- Map<String, PropertyDataDefinition> properties = toscaElement.getProperties();
- if(MapUtils.isNotEmpty(properties)) {
- List<PropertyDefinition> propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList());
- component.setProperties(propertiesMap);
- }
-
- //archive
- component.setArchived(toscaElement.isArchived() == null ? false : toscaElement.isArchived());
-
-
- //component.setArchiveTime(toscaElement.getArchiveTime() == null ? 0L : toscaElement.getArchiveTime());
+ if(toscaElement.getModel() != null) {
+ component.setModel(toscaElement.getModel());
+ }
+ Map<String, PropertyDataDefinition> properties = toscaElement.getProperties();
+ if (MapUtils.isNotEmpty(properties)) {
+ List<PropertyDefinition> propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList());
+ component.setProperties(propertiesMap);
+ }
+ //archive
+ component.setArchived(toscaElement.isArchived() == null ? false : toscaElement.isArchived());
component.setArchiveTime(toscaElement.getArchiveTime());
component.setVspArchived(toscaElement.isVspArchived() == null ? false : toscaElement.isVspArchived());
-
if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
Resource resource = (Resource) component;
resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME));
resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE));
// field isn't mandatory , but shouldn't be null(should be an empty string instead)
- if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null){
+ if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null) {
resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER));
} else {
resource.setResourceVendorModelNumber("");
}
+ Boolean isNormative = toscaElement.getMetadataValue(JsonPresentationFields.NORMATIVE) == null ? false : (Boolean) toscaElement.getMetadataValue(JsonPresentationFields.NORMATIVE);
+ resource.getComponentMetadataDefinition().getMetadataDataDefinition().setNormative(isNormative);
} else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
Service service = (Service) component;
- if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null){
+ if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null) {
service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE));
} else {
service.setServiceType("");
}
- if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null){
+ if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null) {
service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE));
} else {
service.setServiceRole("");
}
- if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_FUNCTION)) != null){
+ if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_FUNCTION)) != null) {
service.setServiceFunction((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_FUNCTION));
} else {
service.setServiceFunction("");
component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID));
component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID));
component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED));
+ component.setModel((String) toscaElement.getMetadataValue(JsonPresentationFields.MODEL));
component.setToscaType(toscaElement.getToscaType().getValue());
+ final List<MetadataKeyDataDefinition> metadataKeys = getCategorySpecificMetadataKeys(toscaElement);
+ if (CollectionUtils.isNotEmpty(metadataKeys)) {
+ final Map<String, String> categorySpecificMetadata = new HashMap<>();
+ for (final MetadataKeyDataDefinition metadataKey : metadataKeys) {
+ if (toscaElement.getMetadata().get(metadataKey.getName()) != null) {
+ categorySpecificMetadata.put(metadataKey.getName(), (String) toscaElement.getMetadata().get(metadataKey.getName()));
+ } else if (metadataKey.getDefaultValue() != null && metadataKey.isMandatory()) {
+ categorySpecificMetadata.put(metadataKey.getName(), metadataKey.getDefaultValue());
+ }
+ }
+ component.setCategorySpecificMetadata(categorySpecificMetadata);
+ }
+ }
+
+ private static List<MetadataKeyDataDefinition> getCategorySpecificMetadataKeys(final ToscaElement toscaElement) {
+ final List<MetadataKeyDataDefinition> metadataKeys = new ArrayList<>();
+ final Optional<CategoryDefinition> category = getCategory(toscaElement);
+ if (category.isPresent()) {
+ if (CollectionUtils.isNotEmpty(category.get().getMetadataKeys())) {
+ metadataKeys.addAll(category.get().getMetadataKeys());
+ }
+ final Optional<SubCategoryDefinition> subCategory = getSubCategory(category.get());
+ if (subCategory.isPresent() && CollectionUtils.isNotEmpty(subCategory.get().getMetadataKeys())) {
+ metadataKeys.addAll(subCategory.get().getMetadataKeys());
+ }
+ }
+ return metadataKeys;
+ }
+
+ private static Optional<CategoryDefinition> getCategory(ToscaElement toscaElement) {
+ return CollectionUtils.isEmpty(toscaElement.getCategories()) ? Optional.empty() : Optional.of(toscaElement.getCategories().get(0));
+ }
+
+ private static Optional<SubCategoryDefinition> getSubCategory(CategoryDefinition category) {
+ return CollectionUtils.isEmpty(category.getSubcategories()) ? Optional.empty() : Optional.of(category.getSubcategories().get(0));
}
private static NodeType convertToNodeType(Component component) {
nodeType.setDerivedFrom(resource.getDerivedFrom());
nodeType.setDerivedList(resource.getDerivedList());
nodeType.setResourceType(resource.getResourceType());
+ final String toscaVersion = resource.getToscaVersion();
+ if (toscaVersion != null) {
+ nodeType.setToscaVersion(toscaVersion);
+ }
+ final List<DataTypeDefinition> dataTypes = resource.getDataTypes();
+ if (CollectionUtils.isNotEmpty(dataTypes)) {
+ nodeType
+ .setDataTypes(dataTypes.stream().collect(Collectors.toMap(DataTypeDefinition::getName, dataTypeDefinition -> dataTypeDefinition)));
+ }
convertCommonToscaData(component, nodeType);
convertAdditionalInformation(component, nodeType);
convertArtifacts(resource, nodeType);
convertCapabilities(resource, nodeType);
convertRequirements(resource, nodeType);
- convertAttributes(resource, nodeType);
+ convertAttributesToNodeType(resource, nodeType);
convertProperties(resource, nodeType);
convertInterfaces(resource, nodeType);
return nodeType;
private static void convertProperties(Resource resource, NodeType nodeType) {
List<PropertyDefinition> properties = resource.getProperties();
if (properties != null && !properties.isEmpty()) {
- Map<String, PropertyDataDefinition> propertiesMap = properties.stream().collect(Collectors.toMap(PropertyDefinition::getName, PropertyDataDefinition::new));
+ Map<String, PropertyDataDefinition> propertiesMap = properties.stream()
+ .collect(Collectors.toMap(PropertyDefinition::getName, PropertyDataDefinition::new));
nodeType.setProperties(propertiesMap);
}
}
private static void convertInterfaces(Resource resource, NodeType nodeType) {
Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
if (interfaces != null) {
- Map<String, InterfaceDataDefinition> interfaceArtifacts = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, x -> new InterfaceDataDefinition(x.getValue())));
+ Map<String, InterfaceDataDefinition> interfaceArtifacts = interfaces.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, x -> new InterfaceDataDefinition(x.getValue())));
nodeType.setInterfaceArtifacts(interfaceArtifacts);
}
}
private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) {
List<AdditionalInformationDefinition> additionalInformation = component.getAdditionalInformation();
if (additionalInformation != null) {
- Map<String, AdditionalInfoParameterDataDefinition> addInfo = additionalInformation.stream().collect(Collectors.toMap(AdditionalInformationDefinition::getUniqueId, AdditionalInfoParameterDataDefinition::new));
+ Map<String, AdditionalInfoParameterDataDefinition> addInfo = additionalInformation.stream()
+ .collect(Collectors.toMap(AdditionalInformationDefinition::getUniqueId, AdditionalInfoParameterDataDefinition::new));
toscaElement.setAdditionalInformation(addInfo);
}
}
private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) {
Map<String, AdditionalInfoParameterDataDefinition> additionalInformation = toscaElement.getAdditionalInformation();
if (additionalInformation != null) {
- List<AdditionalInformationDefinition> addInfo = additionalInformation.values().stream().map(AdditionalInformationDefinition::new).collect(Collectors.toList());
+ List<AdditionalInformationDefinition> addInfo = additionalInformation.values().stream().map(AdditionalInformationDefinition::new)
+ .collect(Collectors.toList());
resource.setAdditionalInformation(addInfo);
}
}
Map<String, ArtifactDefinition> copy;
if (artifacts != null) {
copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
-
} else {
copy = new HashMap<>();
}
component.setArtifacts(copy);
-
Map<String, ArtifactDataDefinition> toscaArtifacts = toscaElement.getToscaArtifacts();
if (toscaArtifacts != null) {
copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
-
} else {
copy = new HashMap<>();
}
component.setToscaArtifacts(copy);
-
Map<String, ArtifactDataDefinition> deploymentArtifacts = toscaElement.getDeploymentArtifacts();
if (deploymentArtifacts != null) {
copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
-
} else {
copy = new HashMap<>();
}
component.setDeploymentArtifacts(copy);
}
- private static void convertNodeFiltersComponents(TopologyTemplate topologyTemplate, Component component) {
- Map<String, CINodeFilterDataDefinition> filters = topologyTemplate.getNodeFilterComponents();
- Map<String, CINodeFilterDataDefinition> copy;
- if (filters != null) {
+ private static void convertNodeFiltersComponents(final TopologyTemplate topologyTemplate, final Component component) {
+ final Map<String, CINodeFilterDataDefinition> filters = topologyTemplate.getNodeFilterComponents();
+ final Map<String, CINodeFilterDataDefinition> copy;
+ if (MapUtils.isNotEmpty(filters)) {
copy = filters.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new CINodeFilterDataDefinition(e.getValue())));
} else {
copy = new HashMap<>();
component.setNodeFilterComponents(copy);
}
+ private static void convertSubstitutionFiltersComponents(final TopologyTemplate topologyTemplate, final Component component) {
+ final SubstitutionFilterDataDefinition filters = topologyTemplate.getSubstitutionFilters();
+ if (filters == null){
+ component.setSubstitutionFilter(null);
+ return;
+ }
+ component.setSubstitutionFilter(new SubstitutionFilterDataDefinition(filters));
+ }
+
private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) {
Map<String, ArtifactDataDefinition> serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts();
Map<String, ArtifactDefinition> copy;
if (serviceApiArtifacts != null) {
copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
-
} else {
copy = new HashMap<>();
}
service.setServiceApiArtifacts(copy);
}
+
private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) {
Map<String, ForwardingPathDataDefinition> servicePaths = topologyTemplate.getForwardingPaths();
Map<String, ForwardingPathDataDefinition> copy;
if (servicePaths != null) {
copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
-
} else {
copy = new HashMap<>();
}
private static void convertArtifacts(Component component, ToscaElement toscaElement) {
Map<String, ArtifactDefinition> artifacts = component.getArtifacts();
if (artifacts != null) {
- Map<String, ArtifactDataDefinition> copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
+ Map<String, ArtifactDataDefinition> copy = artifacts.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
toscaElement.setArtifacts(copy);
}
-
Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
if (toscaArtifacts != null) {
- Map<String, ArtifactDataDefinition> copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
+ Map<String, ArtifactDataDefinition> copy = toscaArtifacts.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
toscaElement.setToscaArtifacts(copy);
}
-
Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
if (deploymentArtifacts != null) {
- Map<String, ArtifactDataDefinition> copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
+ Map<String, ArtifactDataDefinition> copy = deploymentArtifacts.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
toscaElement.setDeploymentArtifacts(copy);
}
}
private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) {
Map<String, ArtifactDefinition> serviceApiArtifacts = service.getServiceApiArtifacts();
if (serviceApiArtifacts != null) {
- Map<String, ArtifactDataDefinition> copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
+ Map<String, ArtifactDataDefinition> copy = serviceApiArtifacts.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
topologyTemplate.setServiceApiArtifacts(copy);
}
}
private static void convertCapabilities(Component component, NodeType toscaElement) {
Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
-
Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
-
if (capabilities != null && !capabilities.isEmpty()) {
- capabilities.forEach((s, caps) -> {
-
- if (caps != null && !caps.isEmpty()) {
- List<CapabilityDataDefinition> capList = caps.stream().map(CapabilityDataDefinition::new).collect(Collectors.toList());
-
- populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
- }
+ capabilities.forEach((s, caps) -> {
+ if (caps != null && !caps.isEmpty()) {
+ List<CapabilityDataDefinition> capList = caps.stream().map(CapabilityDataDefinition::new).collect(Collectors.toList());
+ populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
}
- );
-
+ });
toscaElement.setCapabilities(toscaCapMap);
toscaElement.setCapabilitiesProperties(toscaCapPropMap);
}
}
- private static void convertAttributes(Resource component, NodeType nodeType) {
- List<PropertyDefinition> attributes = component.getAttributes();
- if (attributes != null) {
- Map<String, PropertyDataDefinition> attrsByName = attributes.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
+ private static void convertAttributesToNodeType(Resource component, NodeType nodeType) {
+ List<AttributeDefinition> attributes = component.getAttributes();
+ if (CollectionUtils.isNotEmpty(attributes)) {
+ Map<String, AttributeDataDefinition> attrsByName = attributes.stream()
+ .collect(Collectors.toMap(AttributeDefinition::getName, Function.identity()));
nodeType.setAttributes(attrsByName);
}
}
private static void convertRequirements(Resource component, NodeType nodeType) {
Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
-
Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
-
if (requirements != null && !requirements.isEmpty()) {
- requirements.forEach((s, reqs)-> {
-
- if (reqs != null && !reqs.isEmpty()) {
- List<RequirementDataDefinition> reqList = reqs.stream().map(RequirementDataDefinition::new).collect(Collectors.toList());
-
- ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
- toscaReqMap.put(s, listRequirementDataDefinition);
- }
+ requirements.forEach((s, reqs) -> {
+ if (reqs != null && !reqs.isEmpty()) {
+ List<RequirementDataDefinition> reqList = reqs.stream().map(RequirementDataDefinition::new).collect(Collectors.toList());
+ ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
+ toscaReqMap.put(s, listRequirementDataDefinition);
}
- );
+ });
nodeType.setRequirements(toscaReqMap);
}
}
private static void convertCapabilities(NodeType toscaElement, Component component) {
Map<String, ListCapabilityDataDefinition> toscaCapabilities = toscaElement.getCapabilities();
Map<String, MapPropertiesDataDefinition> toscaCapPropMap = toscaElement.getCapabilitiesProperties();
-
Map<String, List<CapabilityDefinition>> capabilitiesMapFromMapObject = getCapabilitiesMapFromMapObject(toscaCapabilities, toscaCapPropMap);
if (capabilitiesMapFromMapObject != null) {
component.setCapabilities(capabilitiesMapFromMapObject);
}
}
- public static Map<String, List<CapabilityDefinition>> getCapabilitiesMapFromMapObject(Map<String, ListCapabilityDataDefinition> toscaCapabilities, Map<String, MapPropertiesDataDefinition> toscaCapPropMap) {
+ public static Map<String, List<CapabilityDefinition>> getCapabilitiesMapFromMapObject(Map<String, ListCapabilityDataDefinition> toscaCapabilities,
+ Map<String, MapPropertiesDataDefinition> toscaCapPropMap) {
Map<String, List<CapabilityDefinition>> compCap = new HashMap<>();
- if (toscaCapabilities == null || toscaCapabilities.isEmpty())
+ if (toscaCapabilities == null || toscaCapabilities.isEmpty()) {
return null;
- toscaCapabilities.forEach((s, cap)-> {
-
- if (cap != null) {
- List<CapabilityDataDefinition> capDataList = cap.getListToscaDataDefinition();
-
- if (capDataList != null && !capDataList.isEmpty()) {
- List<CapabilityDefinition> capList = capDataList.stream().map(CapabilityDefinition::new).collect(Collectors.toList());
- compCap.put(s, capList);
- }
- }
-
+ }
+ toscaCapabilities.forEach((s, cap) -> {
+ if (cap != null) {
+ List<CapabilityDataDefinition> capDataList = cap.getListToscaDataDefinition();
+ if (capDataList != null && !capDataList.isEmpty()) {
+ List<CapabilityDefinition> capList = capDataList.stream().map(CapabilityDefinition::new).collect(Collectors.toList());
+ compCap.put(s, capList);
}
- );
+ }
+ });
if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) {
- toscaCapPropMap.forEach((s, capProp)-> {
- String[] result = s.split(CAP_PROP_DELIM);
- if (capProp != null) {
- Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
-
- if (capMap != null && !capMap.isEmpty()) {
- List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList());
-
- List<CapabilityDefinition> cap = compCap.get(result[0]);
- Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
- op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
- }
- }
+ toscaCapPropMap.forEach((s, capProp) -> {
+ String[] result = s.split(CAP_PROP_DELIM);
+ if (capProp != null) {
+ Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
+ if (capMap != null && !capMap.isEmpty()) {
+ List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new)
+ .collect(Collectors.toList());
+ List<CapabilityDefinition> cap = compCap.get(result[0]);
+ Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
+ op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
}
- );
+ }
+ });
}
return compCap;
}
Map<String, GroupDataDefinition> toscaGroups = toscaElement.getGroups();
List<GroupDefinition> groupDefinitions = null;
if (MapUtils.isNotEmpty(toscaGroups)) {
- groupDefinitions = toscaGroups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
+ groupDefinitions = toscaGroups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
}
component.setGroups(groupDefinitions);
}
Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies();
Map<String, PolicyDefinition> policyDefinitions = null;
if (MapUtils.isNotEmpty(policies)) {
- policyDefinitions = policies.values().stream().map(PolicyDefinition::new).collect(Collectors.toMap(PolicyDefinition::getUniqueId, Function.identity()));
+ policyDefinitions = policies.values().stream().map(PolicyDefinition::new)
+ .collect(Collectors.toMap(PolicyDefinition::getUniqueId, Function.identity()));
}
component.setPolicies(policyDefinitions);
}
private static void convertGroups(Component component, TopologyTemplate toscaElement) {
List<GroupDefinition> groupDefinitions = component.getGroups();
Map<String, GroupDataDefinition> groups = new HashMap<>();
-
if (groupDefinitions != null && groups.isEmpty()) {
- groups = groupDefinitions.stream().collect(Collectors.toMap(GroupDefinition::getInvariantName, GroupDefinition::new));
+ groups = groupDefinitions.stream().collect(Collectors.toMap(GroupDefinition::getInvariantName, GroupDefinition::new));
}
toscaElement.setGroups(groups);
}
Map<String, PolicyDefinition> policyDefinitions = component.getPolicies();
Map<String, PolicyDataDefinition> policies = new HashMap<>();
if (MapUtils.isNotEmpty(policyDefinitions)) {
- policies = policyDefinitions.values().stream().collect((Collectors.toMap(PolicyDefinition::getUniqueId, PolicyDataDefinition::new)));
+ policies = policyDefinitions.values().stream().collect((Collectors.toMap(PolicyDefinition::getUniqueId, PolicyDataDefinition::new)));
}
toscaElement.setPolicies(policies);
}
private static void convertRequirements(NodeType toscaElement, Component component) {
Map<String, ListRequirementDataDefinition> toscaRequirements = toscaElement.getRequirements();
-
Map<String, List<RequirementDefinition>> compReqs = new HashMap<>();
- if (toscaRequirements == null || toscaRequirements.isEmpty())
+ if (toscaRequirements == null || toscaRequirements.isEmpty()) {
return;
- toscaRequirements.forEach((s, req) -> {
-
- if (req != null) {
- List<RequirementDataDefinition> reqDataList = req.getListToscaDataDefinition();
-
- if (reqDataList != null && !reqDataList.isEmpty()) {
- List<RequirementDefinition> reqList = reqDataList.stream().map(RequirementDefinition::new).collect(Collectors.toList());
- compReqs.put(s, reqList);
- }
+ }
+ toscaRequirements.forEach((s, req) -> {
+ if (req != null) {
+ List<RequirementDataDefinition> reqDataList = req.getListToscaDataDefinition();
+ if (reqDataList != null && !reqDataList.isEmpty()) {
+ List<RequirementDefinition> reqList = reqDataList.stream().map(RequirementDefinition::new).collect(Collectors.toList());
+ compReqs.put(s, reqList);
}
}
- );
+ });
component.setRequirements(compReqs);
}
TopologyTemplate topologyTemplate;
ComponentTypeEnum componentType = component.getComponentType();
topologyTemplate = new TopologyTemplate();
-
- if (componentType == ComponentTypeEnum.RESOURCE) {
- Resource resource = (Resource) component;
- topologyTemplate.setResourceType(resource.getResourceType());
- topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
- topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
- topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
- convertTopologyTemplateInterfaces(resource, topologyTemplate);
- }
- if (componentType == ComponentTypeEnum.SERVICE) {
- convertServiceSpecificEntities((Service) component, topologyTemplate);
- }
- convertCommonToscaData(component, topologyTemplate);
- convertArtifacts(component, topologyTemplate);
-
+ if (componentType == ComponentTypeEnum.RESOURCE) {
+ Resource resource = (Resource) component;
+ topologyTemplate.setResourceType(resource.getResourceType());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION_ID, resource.getCsarVersionId());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
+ convertTopologyTemplateInterfaces(resource, topologyTemplate);
+ }
+ if (componentType == ComponentTypeEnum.SERVICE) {
+ convertServiceSpecificEntities((Service) component, topologyTemplate);
+ }
+ convertCommonToscaData(component, topologyTemplate);
+ convertArtifacts(component, topologyTemplate);
convertAdditionalInformation(component, topologyTemplate);
convertComponentInstances(component, topologyTemplate);
-
- convertInputs(component, topologyTemplate);
- convertProperties(component, topologyTemplate);
- convertCapabilities(component, topologyTemplate);
- convertGroups(component, topologyTemplate);
- convertPolicies(component, topologyTemplate);
- convertRequirements(component, topologyTemplate);
- convertRelationsToComposition(component, topologyTemplate);
-
+ convertInputs(component, topologyTemplate);
+ convertProperties(component, topologyTemplate);
+ convertAttributesToTopologyTemplate(component, topologyTemplate);
+ convertCapabilities(component, topologyTemplate);
+ convertGroups(component, topologyTemplate);
+ convertPolicies(component, topologyTemplate);
+ convertRequirements(component, topologyTemplate);
+ convertRelationsToComposition(component, topologyTemplate);
return topologyTemplate;
}
- private static void convertTopologyTemplateInterfaces(Resource resource, TopologyTemplate topologyTemplate) {
- Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
- if (interfaces != null && !interfaces.isEmpty()) {
- Map<String, InterfaceDataDefinition> copy = interfaces.entrySet().stream()
- .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue())));
- topologyTemplate.setInterfaces(copy);
- }
- }
-
- private static void convertServiceInterfaces(Service service, TopologyTemplate topologyTemplate) {
- Map<String, InterfaceDefinition> interfaces = service.getInterfaces();
+ private static void convertTopologyTemplateInterfaces(Resource resource, TopologyTemplate topologyTemplate) {
+ Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
if (interfaces != null && !interfaces.isEmpty()) {
Map<String, InterfaceDataDefinition> copy = interfaces.entrySet().stream()
- .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue())));
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue())));
topologyTemplate.setInterfaces(copy);
}
}
private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) {
convertServiceMetaData(service, topologyTemplate);
convertServiceApiArtifacts(service, topologyTemplate);
- convertServicePaths(service,topologyTemplate);
- convertServiceInterfaces(topologyTemplate,service);
+ convertServicePaths(service, topologyTemplate);
+ convertServiceInterfaces(topologyTemplate, service);
}
private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) {
Map<String, ForwardingPathDataDefinition> servicePaths = service.getForwardingPaths();
if (servicePaths != null && !servicePaths.isEmpty()) {
- Map<String, ForwardingPathDataDefinition> copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
+ Map<String, ForwardingPathDataDefinition> copy = servicePaths.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
topologyTemplate.setForwardingPaths(copy);
}
}
- private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
- if (service.getDistributionStatus() != null) {
- topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS,
- service.getDistributionStatus().name());
- }
- topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
- topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING,
- service.isEcompGeneratedNaming());
- topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
- topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext());
- topologyTemplate.setMetadataValue(JsonPresentationFields.INSTANTIATION_TYPE, service.getInstantiationType());
-
+ private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
+ if (service.getDistributionStatus() != null) {
+ topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS, service.getDistributionStatus().name());
+ }
+ topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, service.isEcompGeneratedNaming());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.INSTANTIATION_TYPE, service.getInstantiationType());
}
private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) {
compositionDataDefinition = new CompositionDataDefinition();
compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition);
}
-
- Map<String, RelationshipInstDataDefinition> relations = componentInstancesRelations.stream().flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null)
- .collect(Collectors.toMap(RelationshipInstDataDefinition::getUniqueId, Function.identity()));
+ Map<String, RelationshipInstDataDefinition> relations = componentInstancesRelations.stream()
+ .flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null)
+ .collect(Collectors.toMap(RelationshipInstDataDefinition::getUniqueId, Function.identity()));
compositionDataDefinition.setRelations(relations);
}
}
private static void convertInputs(Component component, TopologyTemplate topologyTemplate) {
List<InputDefinition> inputsList = component.getInputs();
if (inputsList != null && !inputsList.isEmpty()) {
-
- Map<String, PropertyDataDefinition> inputsMap = inputsList.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
+ Map<String, PropertyDataDefinition> inputsMap = inputsList.stream().map(PropertyDataDefinition::new)
+ .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
topologyTemplate.setInputs(inputsMap);
}
+ }
+ private static void convertInputs(TopologyTemplate topologyTemplate, Component component) {
+ Map<String, PropertyDataDefinition> inputsMap = topologyTemplate.getInputs();
+ if (inputsMap != null && !inputsMap.isEmpty()) {
+ List<InputDefinition> inputsList = inputsMap.values().stream().map(InputDefinition::new).collect(Collectors.toList());
+ component.setInputs(inputsList);
+ }
}
- private static void convertInputs(TopologyTemplate topologyTemplate, Component component) {
- Map<String, PropertyDataDefinition> inputsMap = topologyTemplate.getInputs();
- if (inputsMap != null && !inputsMap.isEmpty()) {
- List<InputDefinition> inputsList = inputsMap.values()
- .stream()
- .map(InputDefinition::new)
- .collect(Collectors.toList());
- component.setInputs(inputsList);
- }
- }
-
- private static void convertProperties(Component component, TopologyTemplate topologyTemplate) {
- List<PropertyDefinition> propertiesList = component.getProperties();
- if (propertiesList != null && !propertiesList.isEmpty()) {
- Map<String, PropertyDataDefinition> propertiesMap = propertiesList.stream().map(i -> new PropertyDataDefinition(i)).collect(Collectors.toMap(i -> i.getName(), i -> i));
- topologyTemplate.setProperties(propertiesMap);
- }
-
- }
-
- private static void convertProperties(TopologyTemplate topologyTemplate, Component component) {
- Map<String, PropertyDataDefinition> proeprtiesMap = topologyTemplate.getProperties();
- if (proeprtiesMap != null && !proeprtiesMap.isEmpty()) {
- Map<String, PropertyDefinition> copy = proeprtiesMap.entrySet().stream()
- .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new PropertyDefinition
- (entry.getValue())));
- component.setProperties(new ArrayList<>(copy.values()));
- }
- }
-
- private static void convertDataTypes(TopologyTemplate topologyTemplate, Component component) {
- Map<String, DataTypeDataDefinition> dataTypeDataMap = topologyTemplate.getDataTypes();
- if (MapUtils.isNotEmpty(dataTypeDataMap)) {
- List<DataTypeDefinition> dataTypeMap = dataTypeDataMap.values().stream().map(e -> {
- DataTypeDefinition dataType = new DataTypeDefinition(e);
+ private static void convertOutputs(final TopologyTemplate topologyTemplate, final Component component) {
+ final Map<String, AttributeDataDefinition> outputsMap = topologyTemplate.getOutputs();
+ if (MapUtils.isEmpty(outputsMap)) {
+ return;
+ }
+ final List<OutputDefinition> outputList = outputsMap.values().stream().map(OutputDefinition::new).collect(Collectors.toList());
+ component.setOutputs(outputList);
+ }
+
+ private static void convertProperties(Component component, TopologyTemplate topologyTemplate) {
+ List<PropertyDefinition> propertiesList = component.getProperties();
+ if (propertiesList != null && !propertiesList.isEmpty()) {
+ Map<String, PropertyDataDefinition> propertiesMap = propertiesList.stream().map(i -> new PropertyDataDefinition(i))
+ .collect(Collectors.toMap(i -> i.getName(), i -> i));
+ topologyTemplate.setProperties(propertiesMap);
+ }
+ }
+
+ private static void convertAttributesToTopologyTemplate(final Component component, final TopologyTemplate topologyTemplate) {
+ final List<AttributeDefinition> attributes = component.getAttributes();
+ if (CollectionUtils.isNotEmpty(attributes)) {
+ final Map<String, AttributeDataDefinition> attributeDataDefinitionMap = attributes.stream().map(AttributeDataDefinition::new)
+ .collect(Collectors.toMap(AttributeDataDefinition::getName, i -> i));
+ topologyTemplate.setAttributes(attributeDataDefinitionMap);
+ }
+ }
+
+ private static void convertProperties(TopologyTemplate topologyTemplate, Component component) {
+ Map<String, PropertyDataDefinition> propertiesMap = topologyTemplate.getProperties();
+ if (propertiesMap != null && !propertiesMap.isEmpty()) {
+ Map<String, PropertyDefinition> copy = propertiesMap.entrySet().stream()
+ .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new PropertyDefinition(entry.getValue())));
+ component.setProperties(new ArrayList<>(copy.values()));
+ }
+ }
- if(CollectionUtils.isNotEmpty(e.getPropertiesData())) {
+ private static void convertAttributesToComponent(final TopologyTemplate topologyTemplate, final Component component) {
+ final Map<String, AttributeDataDefinition> attributes = topologyTemplate.getAttributes();
+ if (MapUtils.isNotEmpty(attributes)) {
+ Map<String, AttributeDefinition> copy = attributes.entrySet().stream()
+ .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new AttributeDefinition(entry.getValue())));
+ component.setAttributes(new ArrayList<>(copy.values()));
+ }
+ }
+
+ private static void convertDataTypes(final ToscaElement toscaElement, final Component component) {
+ final Map<String, DataTypeDataDefinition> dataTypeDataMap = toscaElement.getDataTypes();
+ if (MapUtils.isNotEmpty(dataTypeDataMap)) {
+ final List<DataTypeDefinition> dataTypeDefinitionList = dataTypeDataMap.values().stream().map(dataTypeDataDefinition -> {
+ final DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(dataTypeDataDefinition);
+ if (CollectionUtils.isNotEmpty(dataTypeDataDefinition.getPropertiesData())) {
log.debug("#convertDataTypes - propertiesData is not null. {}",
- ReflectionToStringBuilder.toString(e.getPropertiesData()));
- dataType.setProperties(e.getPropertiesData().stream()
- .map(PropertyDefinition::new).collect(Collectors.toList()));
+ ReflectionToStringBuilder.toString(dataTypeDataDefinition.getPropertiesData()));
+ dataTypeDefinition
+ .setProperties(dataTypeDataDefinition.getPropertiesData().stream().map(PropertyDefinition::new).collect(Collectors.toList()));
} else {
log.debug("#convertDataTypes - propertiesData is null. ignore.");
}
- return dataType;
+ return dataTypeDefinition;
}).collect(Collectors.toList());
- component.setDataTypes(dataTypeMap);
+ component.setDataTypes(dataTypeDefinitionList);
}
}
-
private static void convertCommonToscaData(Component component, ToscaElement toscaElement) {
toscaElement.setUUID(component.getUUID());
toscaElement.setUniqueId(component.getUniqueId());
toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId());
toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType());
toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion());
-
//Archive
toscaElement.setArchived(component.isArchived() == null ? false : component.isArchived());
toscaElement.setArchiveTime(component.getArchiveTime() == null ? 0L : component.getArchiveTime());
toscaElement.setVspArchived(component.isVspArchived() == null ? false : component.isVspArchived());
-
toscaElement.setLifecycleState(component.getLifecycleState());
toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion());
if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName());
toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName());
toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease());
+ toscaElement.setMetadataValue(JsonPresentationFields.MODEL, component.getModel());
// field isn't mandatory , but shouldn't be null(should be an empty string instead)
- if (((Resource) component).getResourceVendorModelNumber() != null){
- toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber());
+ if (((Resource) component).getResourceVendorModelNumber() != null) {
+ toscaElement
+ .setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber());
} else {
toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, "");
}
+ toscaElement.setMetadataValue(JsonPresentationFields.NORMATIVE, ((Resource) component).getComponentMetadataDefinition().getMetadataDataDefinition().isNormative());
} else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
// field isn't mandatory , but shouldn't be null(should be an empty string instead)
- if (((Service) component).getServiceType() != null){
+ if (((Service) component).getServiceType() != null) {
toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType());
} else {
toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, "");
}
- if (((Service) component).getServiceRole() != null){
+ if (((Service) component).getServiceRole() != null) {
toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole());
} else {
toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, "");
}
- if (((Service) component).getServiceFunction() != null){
+ if (((Service) component).getServiceFunction() != null) {
toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_FUNCTION, ((Service) component).getServiceFunction());
} else {
toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_FUNCTION, "");
toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags());
toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID());
toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
+ toscaElement.setMetadataValue(JsonPresentationFields.MODEL, component.getModel());
+ toscaElement.setModel(component.getModel());
+ for (final String key : component.getCategorySpecificMetadata().keySet()) {
+ toscaElement.setMetadataValue(key, component.getCategorySpecificMetadata().get(key));
+ }
+ final List<DataTypeDefinition> dataTypes = component.getDataTypes();
+ if (CollectionUtils.isNotEmpty(dataTypes)) {
+ toscaElement
+ .setDataTypes(dataTypes.stream().collect(Collectors.toMap(DataTypeDefinition::getName, dataTypeDefinition -> dataTypeDefinition)));
+ }
}
-
-
-
private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {
-
List<ComponentInstance> componentInstances = new ArrayList<>();
ComponentInstance currComponentInstance;
Map<String, CINodeFilterDataDefinition> nodeFilterComponents = topologyTemplate.getNodeFilterComponents();
-
for (Map.Entry<String, ComponentInstanceDataDefinition> entry : topologyTemplate.getComponentInstances().entrySet()) {
String key = entry.getKey();
currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key));
if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) {
- List<GroupInstance> groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList());
+ List<GroupInstance> groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList());
currComponentInstance.setGroupInstances(groupInstances);
}
setComponentInstanceSource(currComponentInstance, component);
- if(nodeFilterComponents != null && nodeFilterComponents.containsKey(key)){
+ if (MapUtils.isNotEmpty(nodeFilterComponents) && nodeFilterComponents.containsKey(key)) {
currComponentInstance.setNodeFilter(nodeFilterComponents.get(key));
}
- if(topologyTemplate.getInstProperties() != null && topologyTemplate.getInstProperties().containsKey(key) && topologyTemplate.getInstProperties().get(key) != null ){
- List<PropertyDefinition> instanceProps = topologyTemplate.getInstProperties().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new PropertyDefinition(e.getValue())).collect(Collectors.toList());
+ if (topologyTemplate.getInstProperties() != null && topologyTemplate.getInstProperties().containsKey(key)
+ && topologyTemplate.getInstProperties().get(key) != null) {
+ List<PropertyDefinition> instanceProps = topologyTemplate.getInstProperties().get(key).getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new PropertyDefinition(e.getValue())).collect(Collectors.toList());
currComponentInstance.setProperties(instanceProps);
}
- if(topologyTemplate.getInstInputs() != null && topologyTemplate.getInstInputs().containsKey(key) && topologyTemplate.getInstInputs().get(key) != null ){
- List<InputDefinition> instanceInputs = topologyTemplate.getInstInputs().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new InputDefinition(e.getValue())).collect(Collectors.toList());
+ if (topologyTemplate.getInstInputs() != null && topologyTemplate.getInstInputs().containsKey(key)
+ && topologyTemplate.getInstInputs().get(key) != null) {
+ List<InputDefinition> instanceInputs = topologyTemplate.getInstInputs().get(key).getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new InputDefinition(e.getValue())).collect(Collectors.toList());
currComponentInstance.setInputs(instanceInputs);
}
- if(topologyTemplate.getComponentInstInterfaces() != null && topologyTemplate.getComponentInstInterfaces().containsKey(key) && topologyTemplate.getComponentInstInterfaces().get(key) != null ){
- Map<String, Object> interfacesMap = topologyTemplate.getComponentInstInterfaces().get(key).getMapToscaDataDefinition().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+ final Map<String, MapAttributesDataDefinition> instAttributes = topologyTemplate.getInstAttributes();
+ if (instAttributes != null && instAttributes.containsKey(key) && instAttributes.get(key) != null) {
+ currComponentInstance.setAttributes(
+ instAttributes.get(key).getMapToscaDataDefinition().values().stream().map(AttributeDefinition::new).collect(Collectors.toList()));
+ }
+ if (topologyTemplate.getComponentInstInterfaces() != null && topologyTemplate.getComponentInstInterfaces().containsKey(key)
+ && topologyTemplate.getComponentInstInterfaces().get(key) != null) {
+ Map<String, Object> interfacesMap = topologyTemplate.getComponentInstInterfaces().get(key).getMapToscaDataDefinition().entrySet()
+ .stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
currComponentInstance.setInterfaces(interfacesMap);
}
componentInstances.add(currComponentInstance);
-
}
component.setComponentInstances(componentInstances);
}
- public static List<ComponentInstance> getComponentInstancesFromMapObject(Map<String, ComponentInstanceDataDefinition> componentInstancesDefinitionMap, Component component) {
+ public static List<ComponentInstance> getComponentInstancesFromMapObject(
+ Map<String, ComponentInstanceDataDefinition> componentInstancesDefinitionMap, Component component) {
List<ComponentInstance> componentInstances = new ArrayList<>();
ComponentInstance currComponentInstance;
for (Map.Entry<String, ComponentInstanceDataDefinition> entry : componentInstancesDefinitionMap.entrySet()) {
}
private static void setComponentInstanceSource(ComponentInstance currComponentInstance, Component component) {
- if (Objects.isNull(currComponentInstance.getCreatedFrom())){
- if (ComponentTypeEnum.RESOURCE.equals(component.getComponentType())){
+ if (Objects.isNull(currComponentInstance.getCreatedFrom())) {
+ if (ComponentTypeEnum.RESOURCE.equals(component.getComponentType())) {
Resource resource = (Resource) component;
- if (isFromCsar(resource)){
+ if (isFromCsar(resource)) {
currComponentInstance.setCreatedFrom(CreatedFrom.CSAR);
- }
- else {
+ } else {
currComponentInstance.setCreatedFrom(CreatedFrom.UI);
}
}
}
private static boolean isFromCsar(Resource resource) {
- return resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.CVFC;
+ return resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.CVFC
+ || resource.getResourceType() == ResourceTypeEnum.PNF;
}
private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) {
for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstInputs().entrySet()) {
if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
String key = entry.getKey();
- List<ComponentInstanceInput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList());
+ List<ComponentInstanceInput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList());
inputs.put(key, componentInstanceAttributes);
}
}
}
}
+ private static void setComponentInstancesOutputsToComponent(final TopologyTemplate topologyTemplate, final Component component) {
+ if (topologyTemplate.getInstOutputs() != null) {
+ final Map<String, List<ComponentInstanceOutput>> outputs = new HashMap<>();
+ for (final Entry<String, MapAttributesDataDefinition> entry : topologyTemplate.getInstOutputs().entrySet()) {
+ if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
+ final String key = entry.getKey();
+ final List<ComponentInstanceOutput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new ComponentInstanceOutput(e.getValue())).collect(Collectors.toList());
+ outputs.put(key, componentInstanceAttributes);
+ }
+ }
+ component.setComponentInstancesOutputs(outputs);
+ }
+ }
+
private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) {
if (topologyTemplate.getInstProperties() != null) {
Map<String, List<ComponentInstanceProperty>> properties = new HashMap<>();
for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstProperties().entrySet()) {
if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
String key = entry.getKey();
- List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue())))
- .collect(Collectors.toList());
+ List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue()))).collect(Collectors.toList());
properties.put(key, componentInstanceAttributes);
}
}
}
}
- public static Map<String, List<ComponentInstanceProperty>> getComponentInstancesAttributes(Map<String, MapPropertiesDataDefinition> mapPropertiesDataDefinition) {
- Map<String, List<ComponentInstanceProperty>> attributes = new HashMap<>();
- for (Map.Entry<String, MapPropertiesDataDefinition> entry : mapPropertiesDataDefinition.entrySet()) {
+ public static Map<String, List<ComponentInstanceAttribute>> getComponentInstancesAttributes(
+ Map<String, MapAttributesDataDefinition> mapAttributesDataDefinitionMap) {
+ Map<String, List<ComponentInstanceAttribute>> attributes = new HashMap<>();
+ for (Map.Entry<String, MapAttributesDataDefinition> entry : mapAttributesDataDefinitionMap.entrySet()) {
if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
String key = entry.getKey();
- List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new ComponentInstanceProperty(e.getValue())))
- .collect(Collectors.toList());
+ List<ComponentInstanceAttribute> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new ComponentInstanceAttribute(new AttributeDefinition(e.getValue()))).collect(Collectors.toList());
attributes.put(key, componentInstanceAttributes);
}
}
for (Map.Entry<String, MapInterfaceInstanceDataDefinition> entry : topologyTemplate.getInstInterfaces().entrySet()) {
if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
String key = entry.getKey();
- List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue()
- .getMapToscaDataDefinition().entrySet().stream().map(e -> new
- ComponentInstanceInterface(e.getKey(), e.getValue()))
- .collect(Collectors.toList());
+ List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new ComponentInstanceInterface(e.getKey(), e.getValue())).collect(Collectors.toList());
interfaces.put(key, componentInstanceInterfaces);
}
}
component.setComponentInstancesInterfaces(interfaces);
- }
- else if (topologyTemplate.getComponentInstInterfaces() != null) {
+ } else if (topologyTemplate.getComponentInstInterfaces() != null) {
Map<String, List<ComponentInstanceInterface>> interfaces = new HashMap<>();
for (Map.Entry<String, MapInterfaceDataDefinition> entry : topologyTemplate.getComponentInstInterfaces().entrySet()) {
if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
String key = entry.getKey();
- List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue()
- .getMapToscaDataDefinition().entrySet().stream().map(e -> new
- ComponentInstanceInterface(e.getKey(), e.getValue()))
- .collect(Collectors.toList());
+ List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new ComponentInstanceInterface(e.getKey(), e.getValue())).collect(Collectors.toList());
interfaces.put(key, componentInstanceInterfaces);
}
}
component.setComponentInstancesInterfaces(interfaces);
}
-
}
private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) {
if (topologyTemplate.getInstAttributes() != null) {
- Map<String, List<ComponentInstanceProperty>> attributes = new HashMap<>();
- for (Map.Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstAttributes().entrySet()) {
+ Map<String, List<ComponentInstanceAttribute>> attributes = new HashMap<>();
+ for (Map.Entry<String, MapAttributesDataDefinition> entry : topologyTemplate.getInstAttributes().entrySet()) {
if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
String key = entry.getKey();
- List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new ComponentInstanceProperty(e.getValue())))
- .collect(Collectors.toList());
+ List<ComponentInstanceAttribute> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
+ .map(e -> new ComponentInstanceAttribute(new AttributeDefinition(e.getValue()))).collect(Collectors.toList());
attributes.put(key, componentInstanceAttributes);
}
}
}
}
-
public static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
-
if (topologyTemplate.getCalculatedRequirements() != null) {
// Requirements of component organized by capability
- Map<String, List<RequirementDefinition>> instanceRequiermentsFromMapObject = getInstanceRequirementsFromMapObject(topologyTemplate.getCalculatedRequirements(), component);
+ Map<String, List<RequirementDefinition>> instanceRequiermentsFromMapObject = getInstanceRequirementsFromMapObject(
+ topologyTemplate.getCalculatedRequirements(), component);
component.setRequirements(instanceRequiermentsFromMapObject);
}
}
- public static Map<String, List<RequirementDefinition>> getInstanceRequirementsFromMapObject(Map<String, MapListRequirementDataDefinition> mapListRequirements, Component component) {
+ public static Map<String, List<RequirementDefinition>> getInstanceRequirementsFromMapObject(
+ Map<String, MapListRequirementDataDefinition> mapListRequirements, Component component) {
// Requirements of component organized by capability
Map<String, List<RequirementDefinition>> instancesRequirements = new HashMap<>();
- if (mapListRequirements!= null) {
+ if (mapListRequirements != null) {
Map<String, ComponentInstance> instancesMap = new HashMap<>();
for (ComponentInstance currInstance : component.getComponentInstances()) {
instancesMap.put(currInstance.getUniqueId(), currInstance);
}
for (Map.Entry<String, MapListRequirementDataDefinition> entry : mapListRequirements.entrySet()) {
-
String instanceId = entry.getKey();
// Requirements of instance organized by capability
Map<String, ListRequirementDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
-
- if(capsMapList != null) {
+ if (capsMapList != null) {
for (Entry<String, ListRequirementDataDefinition> entryTypeList : capsMapList.entrySet()) {
String capabilityType = entryTypeList.getKey();
- List<RequirementDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(RequirementDefinition::new).collect(Collectors.toList());
+ List<RequirementDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
+ .map(RequirementDefinition::new).collect(Collectors.toList());
if (instancesRequirements.containsKey(capabilityType)) {
instancesRequirements.get(capabilityType).addAll(caps);
} else {
}
component.setRequirements(instancesRequirements);
}
- return instancesRequirements;
+ return instancesRequirements;
}
public static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) {
Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
-
if (topologyTemplate.getCalculatedCapabilities() != null) {
// capabilities of component organized by type
Map<String, List<CapabilityDefinition>> instancesCapabilities = new HashMap<>();
-
Map<String, ComponentInstance> instancesMap = new HashMap<>();
for (ComponentInstance currInstance : component.getComponentInstances()) {
instancesMap.put(currInstance.getUniqueId(), currInstance);
}
for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
-
String instanceId = entry.getKey();
// capabilities of instance organized by type
Map<String, ListCapabilityDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
-
- if(capsMapList != null) {
+ if (capsMapList != null) {
for (Entry<String, ListCapabilityDataDefinition> entryTypeList : capsMapList.entrySet()) {
String capabilityType = entryTypeList.getKey();
- List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList());
+ List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
+ .map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList());
if (instancesCapabilities.containsKey(capabilityType)) {
instancesCapabilities.get(capabilityType).addAll(caps);
} else {
}
ComponentInstance instance = instancesMap.get(instanceId);
if (instance == null) {
- log.error("instance is null for id {} entry {}", instanceId, entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME));
+ log.error("instance is null for id {} entry {}", instanceId,
+ entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME));
} else {
if (MapUtils.isEmpty(instance.getCapabilities())) {
instance.setCapabilities(new HashMap<>());
Map<String, ListCapabilityDataDefinition> capabilities = topologyTemplate.getCapabilities();
Map<String, MapPropertiesDataDefinition> capabilitiesProperties = topologyTemplate.getCapabilitiesProperties();
Map<String, List<CapabilityDefinition>> allCapabilities = new HashMap<>();
-
- if(MapUtils.isNotEmpty(capabilities)) {
+ if (MapUtils.isNotEmpty(capabilities)) {
allCapabilities.putAll(groupCapabilityByType(capabilities));
}
-
- if(MapUtils.isNotEmpty(capabilitiesProperties)) {
- capabilitiesProperties.forEach((s, capProp)-> {
- String[] result = s.split(CAP_PROP_DELIM);
- if (capProp != null) {
- Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
-
- if (MapUtils.isNotEmpty(capMap)) {
- List<ComponentInstanceProperty> capPropsList = capMap.values().stream()
- .map(ComponentInstanceProperty::new).collect(Collectors.toList());
-
- List<CapabilityDefinition> cap = allCapabilities.get(result[0]);
- if (cap !=null) {
- Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName()
- .equals(result[1])).findFirst();
- op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
- }
- }
+ if (MapUtils.isNotEmpty(capabilitiesProperties)) {
+ capabilitiesProperties.forEach((s, capProp) -> {
+ String[] result = s.split(CAP_PROP_DELIM);
+ if (capProp != null) {
+ Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
+ if (MapUtils.isNotEmpty(capMap)) {
+ List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new)
+ .collect(Collectors.toList());
+ List<CapabilityDefinition> cap = allCapabilities.get(result[0]);
+ if (cap != null) {
+ Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
+ op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
}
}
- );
+ }
+ });
}
Map<String, List<CapabilityDefinition>> componentCapabilities = component.getCapabilities();
- if(MapUtils.isNotEmpty(componentCapabilities)) {
+ if (MapUtils.isNotEmpty(componentCapabilities)) {
mergeCapabilityMap(allCapabilities, componentCapabilities);
}
component.setCapabilities(allCapabilities);
}
- private static void mergeCapabilityMap(Map<String, List<CapabilityDefinition>> map1,
- Map<String, List<CapabilityDefinition>> map2) {
+ private static void mergeCapabilityMap(Map<String, List<CapabilityDefinition>> map1, Map<String, List<CapabilityDefinition>> map2) {
map1.forEach((key1, val1) -> map2.forEach((key2, val2) -> {
- if(key1.equals(key2)) {
+ if (key1.equals(key2)) {
val2.addAll(val1);
}
}));
map1.putAll(map2);
}
- private static Map<String, List<CapabilityDefinition>> groupCapabilityByType(Map<String,
- ListCapabilityDataDefinition> capabilities) {
- Map<String, List<CapabilityDefinition>> groupedCapabilities = new HashMap<>();
-
+ private static Map<String, List<CapabilityDefinition>> groupCapabilityByType(Map<String, ListCapabilityDataDefinition> capabilities) {
+ Map<String, List<CapabilityDefinition>> groupedCapabilities = new HashMap<>();
Set<String> typesSet = new HashSet<>();
List<CapabilityDefinition> allCapabilityDefinitions = new ArrayList<>();
for (Entry<String, ListCapabilityDataDefinition> capabilitiesEntry : capabilities.entrySet()) {
- typesSet.addAll( capabilitiesEntry.getValue().getListToscaDataDefinition()
- .stream().map(CapabilityDataDefinition::getType).collect(Collectors.toSet()));
-
- allCapabilityDefinitions.addAll(capabilitiesEntry.getValue().getListToscaDataDefinition()
- .stream().map(CapabilityDefinition::new).collect(Collectors.toList()));
+ typesSet.addAll(capabilitiesEntry.getValue().getListToscaDataDefinition().stream().map(CapabilityDataDefinition::getType)
+ .collect(Collectors.toSet()));
+ allCapabilityDefinitions.addAll(
+ capabilitiesEntry.getValue().getListToscaDataDefinition().stream().map(CapabilityDefinition::new).collect(Collectors.toList()));
}
-
- for(String capType : typesSet) {
- groupedCapabilities.put(capType, allCapabilityDefinitions.stream()
- .filter(capabilityDefinition -> capabilityDefinition.getType()
- .equals(capType)).collect(Collectors.toList()));
+ for (String capType : typesSet) {
+ groupedCapabilities.put(capType,
+ allCapabilityDefinitions.stream().filter(capabilityDefinition -> capabilityDefinition.getType().equals(capType))
+ .collect(Collectors.toList()));
}
return groupedCapabilities;
}
private static void setRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
Map<String, ListRequirementDataDefinition> requirements = topologyTemplate.getRequirements();
Map<String, List<RequirementDefinition>> componentRequirements = component.getRequirements();
- if(MapUtils.isNotEmpty(requirements)) {
- if(componentRequirements == null) {
+ if (MapUtils.isNotEmpty(requirements)) {
+ if (componentRequirements == null) {
componentRequirements = new HashMap<>();
}
componentRequirements.putAll(groupRequirementByType(requirements));
}
}
- private static Map<String, List<RequirementDefinition>> groupRequirementByType(Map<String,
- ListRequirementDataDefinition> requirements) {
- Map<String, List<RequirementDefinition>> groupedRequirement = new HashMap<>();
-
+ private static Map<String, List<RequirementDefinition>> groupRequirementByType(Map<String, ListRequirementDataDefinition> requirements) {
+ Map<String, List<RequirementDefinition>> groupedRequirement = new HashMap<>();
Set<String> typesSet = new HashSet<>();
List<RequirementDefinition> allRequirements = new ArrayList<>();
for (Entry<String, ListRequirementDataDefinition> requirementsEntry : requirements.entrySet()) {
- typesSet.addAll( requirementsEntry.getValue().getListToscaDataDefinition()
- .stream().map(RequirementDataDefinition::getCapability).collect(Collectors.toSet()));
-
- allRequirements.addAll(requirementsEntry.getValue().getListToscaDataDefinition()
- .stream().map(RequirementDefinition::new).collect(Collectors.toList()));
+ typesSet.addAll(requirementsEntry.getValue().getListToscaDataDefinition().stream().map(RequirementDataDefinition::getCapability)
+ .collect(Collectors.toSet()));
+ allRequirements.addAll(
+ requirementsEntry.getValue().getListToscaDataDefinition().stream().map(RequirementDefinition::new).collect(Collectors.toList()));
}
-
- for(String capType : typesSet) {
- groupedRequirement.put(capType, allRequirements.stream().filter(requirementDefinition ->
- requirementDefinition.getCapability().equals(capType)).collect(Collectors.toList()));
+ for (String capType : typesSet) {
+ groupedRequirement.put(capType,
+ allRequirements.stream().filter(requirementDefinition -> requirementDefinition.getCapability().equals(capType))
+ .collect(Collectors.toList()));
}
return groupedRequirement;
+ }
+ private static void setCapabilitiesToComponentAndGroups(TopologyTemplate topologyTemplate, Component component) {
+ Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
+ if (capabilitiesAndGroupsExist(topologyTemplate, component)) {
+ Map<String, GroupDefinition> groupsMap = component.getGroups().stream()
+ .collect(Collectors.toMap(GroupDefinition::getUniqueId, Function.identity()));
+ for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
+ findSetCapabilitiesToComponentAndGroup(calculatedCapProperties, component, groupsMap, entry);
+ }
+ }
}
+ private static boolean capabilitiesAndGroupsExist(TopologyTemplate topologyTemplate, Component component) {
+ return MapUtils.isNotEmpty(topologyTemplate.getCalculatedCapabilities()) && CollectionUtils.isNotEmpty(component.getGroups());
+ }
- private static void setCapabilitiesToComponentAndGroups(TopologyTemplate topologyTemplate, Component component) {
+ private static void findSetCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component,
+ Map<String, GroupDefinition> groupsMap,
+ Map.Entry<String, MapListCapabilityDataDefinition> entry) {
+ String uniqueId = entry.getKey();
+ if (groupsMap.containsKey(uniqueId)) {
+ setCapabilitiesToComponentAndGroup(calculatedCapProperties, component, entry, groupsMap.get(uniqueId));
+ } else {
+ log.warn("The group with uniqueId {} was not found", uniqueId);
+ }
+ }
- Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
-
- if (capabilitiesAndGroupsExist(topologyTemplate, component)) {
- Map<String, GroupDefinition> groupsMap = component.getGroups().stream().collect(Collectors.toMap(GroupDefinition::getUniqueId,Function.identity()));
-
- for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
- findSetCapabilitiesToComponentAndGroup(calculatedCapProperties, component, groupsMap, entry);
- }
- }
- }
-
- private static boolean capabilitiesAndGroupsExist(TopologyTemplate topologyTemplate, Component component) {
- return MapUtils.isNotEmpty(topologyTemplate.getCalculatedCapabilities()) && CollectionUtils.isNotEmpty(component.getGroups());
- }
-
- private static void findSetCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component, Map<String, GroupDefinition> groupsMap, Map.Entry<String, MapListCapabilityDataDefinition> entry) {
-
- String uniqueId = entry.getKey();
- if(groupsMap.containsKey(uniqueId)){
- setCapabilitiesToComponentAndGroup(calculatedCapProperties, component, entry, groupsMap.get(uniqueId));
- } else {
- log.warn("The group with uniqueId {} was not found", uniqueId);
- }
- }
-
- private static void setCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component, Map.Entry<String, MapListCapabilityDataDefinition> entry, GroupDefinition group) {
-
- for (Entry<String, ListCapabilityDataDefinition> entryTypeList : entry.getValue().getMapToscaDataDefinition().entrySet()) {
- String capabilityType = entryTypeList.getKey();
- List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, group.getUniqueId(), calculatedCapProperties)).collect(Collectors.toList());
- if (component.getCapabilities().containsKey(capabilityType)) {
- component.getCapabilities().get(capabilityType).addAll(caps);
- } else {
- component.getCapabilities().put(capabilityType, caps);
- }
- group.getCapabilities().put(capabilityType, Lists.newArrayList(caps));
- }
- }
-
- private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String ownerId, Map<String, MapCapabilityProperty> calculatedCapProperties) {
+ private static void setCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component,
+ Map.Entry<String, MapListCapabilityDataDefinition> entry, GroupDefinition group) {
+ for (Entry<String, ListCapabilityDataDefinition> entryTypeList : entry.getValue().getMapToscaDataDefinition().entrySet()) {
+ String capabilityType = entryTypeList.getKey();
+ List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
+ .map(cap -> mergeInstCapabiltyWithProperty(cap, group.getUniqueId(), calculatedCapProperties)).collect(Collectors.toList());
+ if (component.getCapabilities().containsKey(capabilityType)) {
+ component.getCapabilities().get(capabilityType).addAll(caps);
+ } else {
+ component.getCapabilities().put(capabilityType, caps);
+ }
+ group.getCapabilities().put(capabilityType, Lists.newArrayList(caps));
+ }
+ }
+
+ private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String ownerId,
+ Map<String, MapCapabilityProperty> calculatedCapProperties) {
CapabilityDefinition capability = new CapabilityDefinition(cap);
if (calculatedCapProperties != null) {
- MapCapabilityProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(ownerId);
+ MapCapabilityProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(ownerId);
if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) {
Map<String, MapPropertiesDataDefinition> toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition();
- toscaCapPropMap.forEach(( keyPath, capProp)-> findConvertSetProperties(cap, ownerId, capability, keyPath, capProp));
- }
- }
- return capability;
- }
-
- private static void findConvertSetProperties(CapabilityDataDefinition cap, String primaryPathKey, CapabilityDefinition capability, String path, MapPropertiesDataDefinition capProp) {
- // format key of capability properties :
- // VF instance in service : instanceId#ownerId#type#capName
- // VFC instance in VF : instanceId#type#capName -> instanceId=ownerId
- // Group in service : groupName#ownerId#type#capName
- // Group in VF : groupName#type#capName -> groupName=ownerId
- String[] result = path.split(CAP_PROP_DELIM);
- if (result.length < 4) {
- log.debug("wrong key format for capabilty, key {}", capProp);
- return;
- }
- if (relatedPropertiesExist(cap, primaryPathKey, capProp, result)) {
- capability.setProperties(capProp.getMapToscaDataDefinition().values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()));
- }
- }
-
- private static boolean relatedPropertiesExist(CapabilityDataDefinition cap, String primaryPathKey, MapPropertiesDataDefinition capProp, String[] result) {
- return capProp != null && MapUtils.isNotEmpty(capProp.getMapToscaDataDefinition()) && areRelatedProperties(cap, primaryPathKey, result);
- }
-
- private static boolean areRelatedProperties(CapabilityDataDefinition cap, String primaryPathKey, String[] result) {
- int primaryKeyIndex = 0;
- int ownerIndex = 1;
- int typeIndex = result.length - 2;
- int nameIndex = result.length - 1;
- return result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex]) && primaryPathKey.equals(result[primaryKeyIndex]);
+ toscaCapPropMap.forEach((keyPath, capProp) -> findConvertSetProperties(cap, ownerId, capability, keyPath, capProp));
+ }
+ }
+ return capability;
}
- private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
+ private static void findConvertSetProperties(CapabilityDataDefinition cap, String primaryPathKey, CapabilityDefinition capability, String path,
+ MapPropertiesDataDefinition capProp) {
+ // format key of capability properties :
+
+ // VF instance in service : instanceId#ownerId#type#capName
+
+ // VFC instance in VF : instanceId#type#capName -> instanceId=ownerId
+
+ // Group in service : groupName#ownerId#type#capName
+ // Group in VF : groupName#type#capName -> groupName=ownerId
+ String[] result = path.split(CAP_PROP_DELIM);
+ if (result.length < 4) {
+ log.debug("wrong key format for capabilty, key {}", capProp);
+ return;
+ }
+ if (relatedPropertiesExist(cap, primaryPathKey, capProp, result)) {
+ capability.setProperties(
+ capProp.getMapToscaDataDefinition().values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()));
+ }
+ }
+
+ private static boolean relatedPropertiesExist(CapabilityDataDefinition cap, String primaryPathKey, MapPropertiesDataDefinition capProp,
+ String[] result) {
+ return capProp != null && MapUtils.isNotEmpty(capProp.getMapToscaDataDefinition()) && areRelatedProperties(cap, primaryPathKey, result);
+ }
+
+ private static boolean areRelatedProperties(CapabilityDataDefinition cap, String primaryPathKey, String[] result) {
+ int primaryKeyIndex = 0;
+ int ownerIndex = 1;
+ int typeIndex = result.length - 2;
+ int nameIndex = result.length - 1;
+ return result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex])
+ && primaryPathKey.equals(result[primaryKeyIndex]);
+ }
+
+ private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
Map<String, ComponentInstanceDataDefinition> componentInstances = new HashMap<>();
ComponentInstanceDataDefinition convertedInstance;
if (component.getComponentInstances() != null) {
convertedInstance = new ComponentInstanceDataDefinition(instance);
if (instance.getGroupInstances() != null) {
MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition();
-
- groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(GroupInstanceDataDefinition::new).collect(Collectors.toMap(GroupInstanceDataDefinition::getName, Function.identity())));
+ groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(GroupInstanceDataDefinition::new)
+ .collect(Collectors.toMap(GroupInstanceDataDefinition::getName, Function.identity())));
if (topologyTemplate.getInstGroups() == null) {
topologyTemplate.setInstGroups(new HashMap<>());
}
}
}
topologyTemplate.setComponentInstances(componentInstances);
-
}
private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
-
if (component.getComponentInstancesInputs() != null) {
topologyTemplate.setInstInputs(new HashMap<>());
MapPropertiesDataDefinition inputsMap;
for (Entry<String, List<ComponentInstanceInput>> entry : component.getComponentInstancesInputs().entrySet()) {
inputsMap = new MapPropertiesDataDefinition();
-
- inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
-
+ inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new)
+ .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap);
}
}
}
private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
-
if (component.getComponentInstancesProperties() != null) {
topologyTemplate.setInstProperties(new HashMap<>());
MapPropertiesDataDefinition propertiesMap;
for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesProperties().entrySet()) {
propertiesMap = new MapPropertiesDataDefinition();
-
- propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
-
+ propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new)
+ .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap);
}
}
}
private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
-
List<ComponentInstance> componentInstances = component.getComponentInstances();
if (componentInstances != null) {
topologyTemplate.setInstanceArtifacts(new HashMap<>());
topologyTemplate.setInstDeploymentArtifacts(new HashMap<>());
-
for (ComponentInstance ci : componentInstances) {
Map<String, ArtifactDefinition> artifacts = ci.getArtifacts();
if (artifacts != null) {
- Map<String, ArtifactDataDefinition> mapToscaDataDefinitionArtifact = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
+ Map<String, ArtifactDataDefinition> mapToscaDataDefinitionArtifact = artifacts.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact);
topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact);
}
-
Map<String, ArtifactDefinition> deplArtifacts = ci.getDeploymentArtifacts();
if (deplArtifacts != null) {
- Map<String, ArtifactDataDefinition> mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
+ Map<String, ArtifactDataDefinition> mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact);
topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact);
}
}
private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
-
if (component.getComponentInstancesAttributes() != null) {
topologyTemplate.setInstAttributes(new HashMap<>());
- MapPropertiesDataDefinition attributesMap;
- for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesAttributes().entrySet()) {
- attributesMap = new MapPropertiesDataDefinition();
-
- attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
-
+ for (Entry<String, List<ComponentInstanceAttribute>> entry : component.getComponentInstancesAttributes().entrySet()) {
+ final MapAttributesDataDefinition attributesMap = new MapAttributesDataDefinition();
+ attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(AttributeDefinition::new)
+ .collect(Collectors.toMap(AttributeDefinition::getName, Function.identity(), (entity1, entity2) -> entity1)));
topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap);
}
}
public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) {
ComponentMetadataData metadata;
switch (vertex.getType()) {
- case SERVICE:
- metadata = new ServiceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
- break;
- case RESOURCE:
- metadata = new ResourceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
- break;
- case PRODUCT:
- metadata = new ProductMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
- break;
- default:
- throw new StorageException(JanusGraphOperationStatus.INVALID_TYPE);
+ case SERVICE:
+ metadata = new ServiceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
+ break;
+ case RESOURCE:
+ metadata = new ResourceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
+ break;
+ case PRODUCT:
+ metadata = new ProductMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
+ break;
+ default:
+ throw new StorageException(JanusGraphOperationStatus.INVALID_TYPE);
}
metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId());
metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
}
public static List<GroupDefinition> convertToGroupDefinitions(Map<String, GroupDataDefinition> groups) {
-
List<GroupDefinition> groupDefinitions = new ArrayList<>();
if (MapUtils.isNotEmpty(groups)) {
- groupDefinitions = groups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
+ groupDefinitions = groups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
}
return groupDefinitions;
- }
-
- public static Map<String, MapCapabilityProperty> extractCapabilityProperteisFromInstances(List<ComponentInstance> instances, boolean fromCsar) {
- return instances
- .stream()
- .collect(Collectors.toMap(ComponentInstanceDataDefinition::getUniqueId,
- ci -> convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), ci.getUniqueId(), fromCsar)));
- }
-
- public static Map<String, MapCapabilityProperty> extractCapabilityPropertiesFromGroups(List<GroupDefinition> groups, boolean fromCsar) {
- if(CollectionUtils.isNotEmpty(groups))
- return groups
- .stream()
- .collect(Collectors.toMap(GroupDefinition::getUniqueId,
- g -> convertToMapOfMapCapabiltyProperties(g.getCapabilities(), g.getUniqueId(), fromCsar)));
- return Maps.newHashMap();
- }
-
- public static Map<String, MapListCapabilityDataDefinition> extractCapabilitiesFromGroups(final List<GroupDefinition> groupDefinitions) {
- Map<String, MapListCapabilityDataDefinition> calculatedCapabilities = Maps.newHashMap();
- for(GroupDefinition groupDefinition :groupDefinitions){
- calculatedCapabilities.put(groupDefinition.getUniqueId(), new MapListCapabilityDataDefinition(buildMapOfListsOfCapabilities(groupDefinition)));
- }
- return calculatedCapabilities;
- }
-
- private static Map<String, ListCapabilityDataDefinition> buildMapOfListsOfCapabilities(GroupDefinition groupDefinition) {
- return groupDefinition.getCapabilities().entrySet()
- .stream()
- .collect(Collectors.toMap(Map.Entry::getKey, e-> new ListCapabilityDataDefinition(e.getValue()
- .stream()
- .map(CapabilityDataDefinition::new)
- .collect(Collectors.toList()))));
}
+ public static Map<String, MapCapabilityProperty> extractCapabilityProperteisFromInstances(List<ComponentInstance> instances, boolean fromCsar) {
+ return instances.stream().collect(Collectors.toMap(ComponentInstanceDataDefinition::getUniqueId,
+ ci -> convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), ci.getUniqueId(), fromCsar)));
+ }
+
+ public static Map<String, MapCapabilityProperty> extractCapabilityPropertiesFromGroups(List<GroupDefinition> groups, boolean fromCsar) {
+ if (CollectionUtils.isNotEmpty(groups)) {
+ return groups.stream().collect(Collectors
+ .toMap(GroupDefinition::getUniqueId, g -> convertToMapOfMapCapabiltyProperties(g.getCapabilities(), g.getUniqueId(), fromCsar)));
+ }
+ return Maps.newHashMap();
+ }
+
+ public static Map<String, MapListCapabilityDataDefinition> extractCapabilitiesFromGroups(final List<GroupDefinition> groupDefinitions) {
+ Map<String, MapListCapabilityDataDefinition> calculatedCapabilities = Maps.newHashMap();
+ for (GroupDefinition groupDefinition : groupDefinitions) {
+ calculatedCapabilities
+ .put(groupDefinition.getUniqueId(), new MapListCapabilityDataDefinition(buildMapOfListsOfCapabilities(groupDefinition)));
+ }
+ return calculatedCapabilities;
+ }
+
+ private static Map<String, ListCapabilityDataDefinition> buildMapOfListsOfCapabilities(GroupDefinition groupDefinition) {
+ return groupDefinition.getCapabilities().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,
+ e -> new ListCapabilityDataDefinition(e.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))));
+ }
}
Code Review / sdc.git / blobdiff