2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
20 package org.openecomp.sdc.be.model.jsonjanusgraph.utils;
22 import com.google.common.collect.Lists;
23 import com.google.common.collect.Maps;
24 import java.util.ArrayList;
25 import java.util.Arrays;
26 import java.util.Collections;
27 import java.util.HashMap;
28 import java.util.HashSet;
29 import java.util.List;
31 import java.util.Map.Entry;
32 import java.util.Objects;
33 import java.util.Optional;
35 import java.util.function.Function;
36 import java.util.stream.Collectors;
37 import org.apache.commons.collections.CollectionUtils;
38 import org.apache.commons.collections.MapUtils;
39 import org.apache.commons.lang3.BooleanUtils;
40 import org.apache.commons.lang3.StringUtils;
41 import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
42 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
43 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
44 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
45 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionaryExtractor;
46 import org.openecomp.sdc.be.datatypes.category.MetadataKeyDataDefinition;
47 import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
48 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
49 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
50 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
51 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
52 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
53 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
54 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
55 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
56 import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
57 import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition;
58 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
59 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
60 import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
61 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
62 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
63 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
64 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
65 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.MapAttributesDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
68 import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
76 import org.openecomp.sdc.be.datatypes.elements.ProductMetadataDataDefinition;
77 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
78 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
79 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
80 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
81 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
82 import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
83 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
84 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFieldsExtractor;
85 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
86 import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
87 import org.openecomp.sdc.be.model.ArtifactDefinition;
88 import org.openecomp.sdc.be.model.AttributeDefinition;
89 import org.openecomp.sdc.be.model.CapabilityDefinition;
90 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
91 import org.openecomp.sdc.be.model.Component;
92 import org.openecomp.sdc.be.model.ComponentInstance;
93 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
94 import org.openecomp.sdc.be.model.ComponentInstanceInput;
95 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
96 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
97 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
98 import org.openecomp.sdc.be.model.DataTypeDefinition;
99 import org.openecomp.sdc.be.model.DistributionStatusEnum;
100 import org.openecomp.sdc.be.model.GroupDefinition;
101 import org.openecomp.sdc.be.model.GroupInstance;
102 import org.openecomp.sdc.be.model.InputDefinition;
103 import org.openecomp.sdc.be.model.InterfaceDefinition;
104 import org.openecomp.sdc.be.model.MapInterfaceInstanceDataDefinition;
105 import org.openecomp.sdc.be.model.OutputDefinition;
106 import org.openecomp.sdc.be.model.PolicyDefinition;
107 import org.openecomp.sdc.be.model.PropertyDefinition;
108 import org.openecomp.sdc.be.model.RelationshipImpl;
109 import org.openecomp.sdc.be.model.RelationshipInfo;
110 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
111 import org.openecomp.sdc.be.model.RequirementDefinition;
112 import org.openecomp.sdc.be.model.Resource;
113 import org.openecomp.sdc.be.model.Service;
114 import org.openecomp.sdc.be.model.category.CategoryDefinition;
115 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
116 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
117 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
118 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
119 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
120 import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum;
121 import org.openecomp.sdc.be.model.operations.StorageException;
122 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
123 import org.openecomp.sdc.be.resources.data.ProductMetadataData;
124 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
125 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
126 import org.openecomp.sdc.be.ui.model.OperationUi;
127 import org.openecomp.sdc.be.ui.model.PropertyAssignmentUi;
128 import org.openecomp.sdc.common.log.wrappers.Logger;
130 public class ModelConverter {
132 public static final String CAP_PROP_DELIM = "#";
133 private static final Logger log = Logger.getLogger(ModelConverter.class);
135 private ModelConverter() {
138 @SuppressWarnings("unchecked")
139 public static <T extends ToscaElement> T convertToToscaElement(Component component) {
140 if (isAtomicComponent(component)) {
141 return (T) convertToNodeType(component);
143 return (T) convertToTopologyTemplate(component);
146 @SuppressWarnings("unchecked")
147 public static <T extends Component> T convertFromToscaElement(ToscaElement toscaElement) {
148 switch (toscaElement.getComponentType()) {
150 return (T) convertToResource(toscaElement);
153 return (T) convertToService(toscaElement);
159 public static boolean isAtomicComponent(Component component) {
160 ComponentTypeEnum componentType = component.getComponentType();
161 if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
164 Resource resource = (Resource) component;
165 ResourceTypeEnum resType = resource.getResourceType();
166 return isAtomicComponent(resType);
169 public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
170 if (resourceType == null) {
173 return resourceType.isAtomicType();
176 // **********************************************************
177 public static VertexTypeEnum getVertexType(Component component) {
178 VertexTypeEnum vertexType;
179 if (isAtomicComponent(component)) {
180 vertexType = VertexTypeEnum.NODE_TYPE;
182 vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
187 public static VertexTypeEnum getVertexType(String resourceTypeName) {
188 ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName);
189 if (isAtomicComponent(resourceType)) {
190 return VertexTypeEnum.NODE_TYPE;
192 return VertexTypeEnum.TOPOLOGY_TEMPLATE;
196 private static Service convertToService(ToscaElement toscaElement) {
197 Service service = new Service();
198 convertComponentFields(service, toscaElement);
199 convertServiceSpecificFields(toscaElement, service);
200 TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
201 convertComponentInstances(topologyTemplate, service);
202 convertInputs(topologyTemplate, service);
203 convertOutputs(topologyTemplate, service);
204 convertProperties(topologyTemplate, service);
205 convertPolicies(topologyTemplate, service);
206 convertAttributesToComponent(topologyTemplate, service);
207 convertGroups(topologyTemplate, service);
208 setCapabilitiesToComponentAndGroups(topologyTemplate, service);
209 convertPolicies(topologyTemplate, service);
210 convertRelations(topologyTemplate, service);
211 convertArtifacts(topologyTemplate, service);
212 convertServiceApiArtifacts(topologyTemplate, service);
213 convertServicePaths(topologyTemplate, service);
214 convertServiceInterfaces(topologyTemplate, service);
215 convertDataTypes(topologyTemplate, service);
216 convertNodeFiltersComponents(topologyTemplate, service);
217 convertSubstitutionFiltersComponents(topologyTemplate, service);
218 setCapabilitiesToComponent(topologyTemplate, service);
219 setRequirementsToComponent(topologyTemplate, service);
223 private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) {
224 service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE));
225 service.setDistributionStatus(
226 DistributionStatusEnum.findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
227 service.setEcompGeneratedNaming((Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
228 service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, StringUtils.EMPTY));
229 service.setEnvironmentContext((String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT));
230 service.setInstantiationType((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.INSTANTIATION_TYPE, StringUtils.EMPTY));
233 private static Resource convertToResource(ToscaElement toscaElement) {
234 Resource resource = new Resource();
235 convertComponentFields(resource, toscaElement);
236 resource.setResourceType(toscaElement.getResourceType());
237 if (toscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) {
238 NodeType nodeType = (NodeType) toscaElement;
239 resource.setDerivedFrom(nodeType.getDerivedFrom());
240 resource.setDerivedList(nodeType.getDerivedList());
241 resource.setDerivedFromMapOfIdToName(nodeType.getDerivedFromMapOfIdToName());
242 resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
243 final String toscaVersion = nodeType.getToscaVersion();
244 if (toscaVersion != null) {
245 resource.setToscaVersion(toscaVersion);
247 convertAttributesToResource(nodeType, resource);
248 convertCapabilities(nodeType, resource);
249 convertRequirements(nodeType, resource);
250 convertInterfaces(nodeType, resource);
251 convertDataTypes(nodeType, resource);
253 TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
254 if (resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.PNF) {
255 resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
256 resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
257 resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
258 convertInterfaces(topologyTemplate, resource);
260 convertComponentInstances(topologyTemplate, resource);
261 convertRelations(topologyTemplate, resource);
262 convertInputs(topologyTemplate, resource);
263 convertOutputs(topologyTemplate, resource);
264 convertGroups(topologyTemplate, resource);
265 setCapabilitiesToComponentAndGroups(topologyTemplate, resource);
266 convertPolicies(topologyTemplate, resource);
267 convertNodeFiltersComponents(topologyTemplate, resource);
268 convertSubstitutionFiltersComponents(topologyTemplate, resource);
269 convertProperties(topologyTemplate, resource);
270 convertAttributesToComponent(topologyTemplate, resource);
271 setCapabilitiesToComponent(topologyTemplate, resource);
272 setRequirementsToComponent(topologyTemplate, resource);
273 convertDataTypes(topologyTemplate, resource);
275 convertArtifacts(toscaElement, resource);
276 convertAdditionalInformation(toscaElement, resource);
280 private static void convertInterfaces(TopologyTemplate toscaElement, Resource resource) {
281 Map<String, InterfaceDataDefinition> interfaces = toscaElement.getInterfaces();
282 Map<String, InterfaceDefinition> copy;
283 if (interfaces != null) {
284 copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue())));
286 copy = new HashMap<>();
288 resource.setInterfaces(copy);
291 private static void convertServiceInterfaces(TopologyTemplate toscaElement, Service service) {
292 Map<String, InterfaceDataDefinition> interfaces = toscaElement.getInterfaces();
293 Map<String, InterfaceDefinition> copy;
294 if (interfaces != null) {
295 copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue())));
297 copy = new HashMap<>();
299 service.setInterfaces(copy);
302 private static void convertAttributesToResource(NodeType nodeType, Resource resource) {
303 Map<String, AttributeDataDefinition> attributes = nodeType.getAttributes();
304 if (attributes != null) {
305 final Map<String, AttributeDefinition> attributeDefinitionMap = attributes.entrySet().stream()
306 .collect(Collectors.toMap(Entry::getKey, o -> new AttributeDefinition(o.getValue())));
307 resource.setAttributes(new ArrayList<>(attributeDefinitionMap.values()));
311 private static void convertInterfaces(NodeType nodeType, Resource resource) {
312 Map<String, InterfaceDataDefinition> interfaceArtifacts = nodeType.getInterfaceArtifacts();
313 if (interfaceArtifacts != null) {
314 Map<String, InterfaceDefinition> interfaces = interfaceArtifacts.entrySet().stream()
315 .collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue())));
316 resource.setInterfaces(interfaces);
321 * Converts component instances of topology template to component instances of resource
323 * @param topologyTemplate
326 public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) {
327 if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) {
328 setComponentInstancesAttributesToComponent(topologyTemplate, component);
329 setComponentInstancesPropertiesToComponent(topologyTemplate, component);
330 setComponentInstancesInputsToComponent(topologyTemplate, component);
331 setComponentInstancesOutputsToComponent(topologyTemplate, component);
332 setComponentInstancesToComponent(topologyTemplate, component);
333 setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component);
334 setComponentInstancesRequirementsToComponent(topologyTemplate, component);
335 setComponentInstancesArtifactsToComponent(topologyTemplate, component);
336 setComponentInstancesInterfacesToComponent(topologyTemplate, component);
340 private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) {
341 Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts();
342 Map<String, MapArtifactDataDefinition> instanceArtifacts = topologyTemplate.getInstanceArtifacts();
343 setComponentInstancesDeploymentArtifactsToComponent(instDeploymentArtifacts, component);
344 setComponentInstancesInformationalArtifactsToComponent(instanceArtifacts, component);
347 public static void setComponentInstancesInformationalArtifactsToComponent(Map<String, MapArtifactDataDefinition> instanceArtifacts,
348 Component component) {
349 List<ComponentInstance> instances = component.getComponentInstances();
350 if (instanceArtifacts != null && instances != null) {
351 instanceArtifacts.entrySet().forEach(e -> {
352 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
353 if (ci.isPresent()) {
354 Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
355 Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream()
356 .collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
357 ci.get().setArtifacts(deplArt);
363 public static void setComponentInstancesDeploymentArtifactsToComponent(Map<String, MapArtifactDataDefinition> instDeploymentArtifacts,
364 Component component) {
365 List<ComponentInstance> instances = component.getComponentInstances();
366 if (instDeploymentArtifacts != null && instances != null) {
367 instDeploymentArtifacts.entrySet().forEach(e -> {
368 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
369 if (ci.isPresent()) {
370 Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
371 Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream()
372 .collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
373 ci.get().setDeploymentArtifacts(deplArt);
379 public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) {
380 if (!CollectionUtils.isEmpty(component.getComponentInstances())) {
381 setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate);
382 setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate);
383 setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate);
384 setComponentInstancesToTopologyTemplate(component, topologyTemplate);
385 setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate);
389 public static void convertRelations(TopologyTemplate topologyTemplate, Component component) {
390 Map<String, RelationshipInstDataDefinition> relations = topologyTemplate.getRelations();
391 List<RequirementCapabilityRelDef> componentRelations;
392 if (relations != null && !relations.isEmpty()) {
393 componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList());
395 componentRelations = new ArrayList<>();
397 component.setComponentInstancesRelations(componentRelations);
400 public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) {
401 RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
402 requirementCapabilityRelDef.setFromNode(relation.getFromId());
403 requirementCapabilityRelDef.setToNode(relation.getToId());
404 requirementCapabilityRelDef.setOriginUI(BooleanUtils.isTrue(relation.isOriginUI()));
405 CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship();
406 RelationshipInfo relationshipPair = getRelationshipInfo(relation);
407 rel.setRelation(relationshipPair);
408 rel.setOperations(convertToOperations(relation.getInterfaces()));
409 requirementCapabilityRelDef.setRelationships(Arrays.asList(rel));
410 return requirementCapabilityRelDef;
413 private static List<OperationUi> convertToOperations(final ListDataDefinition<InterfaceDataDefinition> interfaces) {
414 if (interfaces == null || interfaces.isEmpty()) {
415 return Collections.emptyList();
417 final List<OperationUi> operationUiList = new ArrayList<>();
418 for (final InterfaceDataDefinition interfaceDataDefinition : interfaces.getListToscaDataDefinition()) {
419 if (MapUtils.isEmpty(interfaceDataDefinition.getOperations())) {
422 for (final Entry<String, OperationDataDefinition> operationEntry : interfaceDataDefinition.getOperations().entrySet()) {
423 final OperationUi operationUi = new OperationUi();
424 operationUi.setOperationType(operationEntry.getKey());
425 operationUi.setInterfaceType(interfaceDataDefinition.getType());
426 final OperationDataDefinition operationDataDefinition = operationEntry.getValue();
427 final ArtifactDataDefinition implementation = operationDataDefinition.getImplementation();
428 if (implementation != null) {
429 operationUi.setImplementation(implementation.getArtifactName());
431 final ListDataDefinition<OperationInputDefinition> inputs = operationDataDefinition.getInputs();
432 if (inputs != null && !inputs.isEmpty()) {
433 final List<OperationInputDefinition> operationInputDefinitionList = inputs.getListToscaDataDefinition();
434 operationInputDefinitionList.forEach(operationInputDefinition -> {
435 final PropertyAssignmentUi propertyAssignmentUi = new PropertyAssignmentUi();
436 propertyAssignmentUi.setName(operationInputDefinition.getLabel());
437 propertyAssignmentUi.setType(operationInputDefinition.getType());
438 propertyAssignmentUi.setValue(operationInputDefinition.getValue());
439 operationUi.addToInputs(propertyAssignmentUi);
442 operationUiList.add(operationUi);
445 return operationUiList;
452 private static RelationshipInfo getRelationshipInfo(RelationshipInstDataDefinition relation) {
453 RelationshipInfo relationshipPair = new RelationshipInfo();
454 relationshipPair.setId(relation.getUniqueId());
455 relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
456 relationshipPair.setCapabilityUid(relation.getCapabilityId());
457 relationshipPair.setCapability(relation.getCapability());
458 relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
459 relationshipPair.setRequirementUid(relation.getRequirementId());
460 relationshipPair.setRequirement(relation.getRequirement());
461 RelationshipImpl relationship = new RelationshipImpl();
462 relationship.setType(relation.getType());
463 relationshipPair.setRelationships(relationship);
464 return relationshipPair;
467 public static List<RelationshipInstDataDefinition> convertRelationToToscaRelation(RequirementCapabilityRelDef relation) {
468 List<RelationshipInstDataDefinition> relationsList = new ArrayList<>();
469 List<CapabilityRequirementRelationship> relationship = relation.getRelationships();
470 relationship.forEach(p -> {
471 RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition();
472 requirementCapabilityRelDef.setFromId(relation.getFromNode());
473 requirementCapabilityRelDef.setToId(relation.getToNode());
474 requirementCapabilityRelDef.setUniqueId(p.getRelation().getId());
475 requirementCapabilityRelDef.setCapabilityOwnerId(p.getRelation().getCapabilityOwnerId());
476 requirementCapabilityRelDef.setCapabilityId(p.getRelation().getCapabilityUid());
477 requirementCapabilityRelDef.setRequirementOwnerId(p.getRelation().getRequirementOwnerId());
478 requirementCapabilityRelDef.setRequirementId(p.getRelation().getRequirementUid());
479 requirementCapabilityRelDef.setRequirement(p.getRelation().getRequirement());
480 requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType());
481 requirementCapabilityRelDef.setCapability(p.getRelation().getCapability());
482 requirementCapabilityRelDef.setOriginUI(relation.isOriginUI());
483 relationsList.add(requirementCapabilityRelDef);
485 return relationsList;
488 private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) {
489 convertTopologyTemplateCapabilities(component, topologyTemplate);
490 if (componentInstancesCapabilitiesExist(component) || groupsCapabilitiesExist(component)) {
491 topologyTemplate.setCalculatedCapabilities(new HashMap<>());
492 topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
494 convertComponentInstancesCapabilities(component, topologyTemplate);
495 convertGroupsCapabilities(component, topologyTemplate);
498 private static void convertGroupsCapabilities(Component component, TopologyTemplate topologyTemplate) {
499 if (groupsCapabilitiesExist(component)) {
500 component.getGroups().stream().filter(g -> MapUtils.isNotEmpty(g.getCapabilities()))
501 .forEach(g -> addCapabilities(topologyTemplate, g.getCapabilities(), g.getUniqueId()));
505 private static void convertTopologyTemplateCapabilities(Component component, ToscaElement toscaElement) {
506 Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
507 Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
508 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
509 if (MapUtils.isNotEmpty(capabilities)) {
510 capabilities.forEach((s, caps) -> {
511 if (CollectionUtils.isNotEmpty(caps)) {
512 List<CapabilityDataDefinition> capList = caps.stream()
513 .filter(capabilityDefinition -> capabilityDefinition.getOwnerId().equals(component.getUniqueId()))
514 .map(CapabilityDataDefinition::new).collect(Collectors.toList());
515 populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
518 toscaElement.setCapabilities(toscaCapMap);
519 toscaElement.setCapabilitiesProperties(toscaCapPropMap);
523 private static void populateCapabilityMap(Map<String, ListCapabilityDataDefinition> toscaCapMap,
524 Map<String, MapPropertiesDataDefinition> toscaCapPropMap, String s, List<CapabilityDefinition> caps,
525 List<CapabilityDataDefinition> capList) {
526 ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList);
527 toscaCapMap.put(s, listCapabilityDataDefinition);
528 for (CapabilityDefinition cap : caps) {
529 List<ComponentInstanceProperty> capPrps = cap.getProperties();
530 if (CollectionUtils.isNotEmpty(capPrps)) {
531 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
532 for (ComponentInstanceProperty cip : capPrps) {
533 PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(cip);
534 propertyDataDefinition.setParentUniqueId(cap.getUniqueId());
535 dataToCreate.put(cip.getName(), propertyDataDefinition);
537 toscaCapPropMap.put(s + CAP_PROP_DELIM + cap.getName(), dataToCreate);
542 private static void convertTopologyTemplateRequirements(Component component, ToscaElement toscaElement) {
543 Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
544 Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
545 if (MapUtils.isNotEmpty(requirements)) {
546 requirements.forEach((s, reqs) -> {
547 if (CollectionUtils.isNotEmpty(reqs)) {
548 List<RequirementDataDefinition> reqList = reqs.stream()
549 .filter(requirementDefinition -> requirementDefinition.getOwnerId().equals(component.getUniqueId()))
550 .map(RequirementDataDefinition::new).collect(Collectors.toList());
551 ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
552 toscaReqMap.put(s, listRequirementDataDefinition);
555 toscaElement.setRequirements(toscaReqMap);
559 private static void convertComponentInstancesCapabilities(Component component, TopologyTemplate topologyTemplate) {
560 if (componentInstancesCapabilitiesExist(component)) {
561 component.getComponentInstances().stream().filter(i -> MapUtils.isNotEmpty(i.getCapabilities()))
562 .forEach(i -> addCapabilities(topologyTemplate, i.getCapabilities(), i.getUniqueId()));
566 private static void addCapabilities(TopologyTemplate topologyTemplate, Map<String, List<CapabilityDefinition>> capabilities, String ownerId) {
567 if (MapUtils.isNotEmpty(capabilities)) {
568 if (topologyTemplate.getCalculatedCapabilities() == null) {
569 topologyTemplate.setCalculatedCapabilities(new HashMap<>());
571 topologyTemplate.getCalculatedCapabilities().put(ownerId, convertToMapListCapabiltyDataDefinition(capabilities));
572 if (topologyTemplate.getCalculatedCapabilitiesProperties() == null) {
573 topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
575 topologyTemplate.getCalculatedCapabilitiesProperties().put(ownerId, convertToMapOfMapCapabiltyProperties(capabilities, ownerId));
579 private static boolean componentInstancesCapabilitiesExist(Component component) {
580 return component.getCapabilities() != null && component.getComponentInstances() != null && component.getComponentInstances().stream()
581 .anyMatch(ci -> MapUtils.isNotEmpty(ci.getCapabilities()));
584 private static boolean groupsCapabilitiesExist(Component component) {
585 return component.getCapabilities() != null && component.getGroups() != null && component.getGroups().stream()
586 .anyMatch(g -> MapUtils.isNotEmpty(g.getCapabilities()));
589 public static MapCapabilityProperty convertToMapOfMapCapabilityProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId,
590 boolean isAtomicType) {
591 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
592 if (MapUtils.isNotEmpty(capabilities)) {
593 capabilities.forEach((s, caps) -> addCapsProperties(ownerId, isAtomicType, toscaCapPropMap, caps));
595 return new MapCapabilityProperty(toscaCapPropMap);
598 private static void addCapsProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap,
599 List<CapabilityDefinition> caps) {
600 if (CollectionUtils.isNotEmpty(caps)) {
601 caps.forEach(cap -> addCapProperties(ownerId, isAtomicType, toscaCapPropMap, cap));
605 private static void addCapProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap,
606 CapabilityDefinition cap) {
607 if (CollectionUtils.isNotEmpty(cap.getProperties())) {
608 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(
609 cap.getProperties().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p)));
610 toscaCapPropMap.put(buildCapabilityPropertyKey(isAtomicType, cap.getType(), cap.getName(), ownerId, cap),
611 new MapPropertiesDataDefinition(dataToCreate));
615 public static String buildCapabilityPropertyKey(boolean isAtomicType, String capabilityType, String capabilityName,
616 String componentInstanceUniqueId, CapabilityDefinition cap) {
617 StringBuilder sb = new StringBuilder(componentInstanceUniqueId);
618 sb.append(CAP_PROP_DELIM).append(cap.getOwnerId()).append(CAP_PROP_DELIM);
619 if (!isAtomicType && !componentInstanceUniqueId.equals(cap.getOwnerId())) {
620 sb.append(cap.getOwnerId()).append(CAP_PROP_DELIM);
622 return sb.append(capabilityType).append(CAP_PROP_DELIM).append(capabilityName).toString();
625 public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities,
627 return convertToMapOfMapCapabiltyProperties(instCapabilities, ownerId, false);
630 public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId,
632 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
633 if (MapUtils.isNotEmpty(capabilities)) {
634 capabilities.forEach((s, caps) -> {
635 if (caps != null && !caps.isEmpty()) {
636 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
637 for (CapabilityDefinition cap : caps) {
638 List<ComponentInstanceProperty> capPrps = cap.getProperties();
639 if (capPrps != null) {
640 for (ComponentInstanceProperty cip : capPrps) {
641 dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
643 // format key of capability properties :
645 // VF instance in service : instanceId#ownerId#type#capName
647 // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId
648 StringBuilder sb = new StringBuilder(ownerId);
649 sb.append(CAP_PROP_DELIM);
653 sb.append(cap.getOwnerId());
655 sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
656 toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate));
662 return new MapCapabilityProperty(toscaCapPropMap);
665 private static MapListCapabilityDataDefinition convertToMapListCapabiltyDataDefinition(Map<String, List<CapabilityDefinition>> instCapabilities) {
666 Map<String, ListCapabilityDataDefinition> mapToscaDataDefinition = new HashMap<>();
667 for (Entry<String, List<CapabilityDefinition>> instCapability : instCapabilities.entrySet()) {
668 mapToscaDataDefinition.put(instCapability.getKey(),
669 new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList())));
671 return new MapListCapabilityDataDefinition(mapToscaDataDefinition);
674 private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) {
675 convertTopologyTemplateRequirements(component, topologyTemplate);
676 if (component.getRequirements() != null && component.getComponentInstances() != null) {
677 topologyTemplate.setCalculatedRequirements(new HashMap<>());
678 for (ComponentInstance instance : component.getComponentInstances()) {
679 Map<String, List<RequirementDefinition>> instRequirements = instance.getRequirements();
680 if (MapUtils.isNotEmpty(instRequirements)) {
681 if (topologyTemplate.getCalculatedRequirements() == null) {
682 topologyTemplate.setCalculatedRequirements(new HashMap<>());
684 topologyTemplate.getCalculatedRequirements()
685 .put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements));
691 private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(
692 Map<String, List<RequirementDefinition>> instRequirements) {
693 Map<String, ListRequirementDataDefinition> mapToscaDataDefinition = new HashMap<>();
694 for (Entry<String, List<RequirementDefinition>> instRequirement : instRequirements.entrySet()) {
695 mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(
696 instRequirement.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList())));
698 return new MapListRequirementDataDefinition(mapToscaDataDefinition);
701 @SuppressWarnings("unchecked")
702 private static void convertComponentFields(Component component, ToscaElement toscaElement) {
703 component.setName(toscaElement.getName());
704 component.setAllVersions(toscaElement.getAllVersions());
705 component.setCategories(toscaElement.getCategories());
706 component.setComponentType(toscaElement.getComponentType());
707 component.setCreationDate(toscaElement.getCreationDate());
708 component.setCreatorUserId(toscaElement.getCreatorUserId());
709 component.setCreatorFullName(toscaElement.getCreatorFullName());
710 component.setLastUpdateDate(toscaElement.getLastUpdateDate());
711 component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName());
712 component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId());
713 component.setNormalizedName(toscaElement.getNormalizedName());
714 component.setLifecycleState(toscaElement.getLifecycleState());
715 component.setVersion(toscaElement.getVersion());
716 component.setHighestVersion(toscaElement.isHighestVersion());
717 component.setUniqueId(toscaElement.getUniqueId());
718 component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME));
719 component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType());
720 component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion());
721 if(toscaElement.getModel() != null) {
722 component.setModel(toscaElement.getModel());
724 Map<String, PropertyDataDefinition> properties = toscaElement.getProperties();
725 if (MapUtils.isNotEmpty(properties)) {
726 List<PropertyDefinition> propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList());
727 component.setProperties(propertiesMap);
730 component.setArchived(toscaElement.isArchived() == null ? false : toscaElement.isArchived());
731 component.setArchiveTime(toscaElement.getArchiveTime());
732 component.setVspArchived(toscaElement.isVspArchived() == null ? false : toscaElement.isVspArchived());
733 if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
734 Resource resource = (Resource) component;
735 resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
736 resource.setToscaResourceName((String) toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
737 resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME));
738 resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE));
739 // field isn't mandatory , but shouldn't be null(should be an empty string instead)
740 if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null) {
741 resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER));
743 resource.setResourceVendorModelNumber("");
745 } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
746 Service service = (Service) component;
747 if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null) {
748 service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE));
750 service.setServiceType("");
752 if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null) {
753 service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE));
755 service.setServiceRole("");
757 if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_FUNCTION)) != null) {
758 service.setServiceFunction((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_FUNCTION));
760 service.setServiceFunction("");
763 component.setConformanceLevel((String) toscaElement.getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL));
764 component.setIcon((String) toscaElement.getMetadataValue(JsonPresentationFields.ICON));
765 component.setDescription((String) toscaElement.getMetadataValue(JsonPresentationFields.DESCRIPTION));
766 component.setTags((List<String>) toscaElement.getMetadataValue(JsonPresentationFields.TAGS));
767 component.setInvariantUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID));
768 component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID));
769 component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID));
770 component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED));
771 component.setModel((String) toscaElement.getMetadataValue(JsonPresentationFields.MODEL));
772 component.setToscaType(toscaElement.getToscaType().getValue());
773 final List<MetadataKeyDataDefinition> metadataKeys = getCategorySpecificMetadataKeys(toscaElement);
774 if (CollectionUtils.isNotEmpty(metadataKeys)) {
775 final Map<String, String> categorySpecificMetadata = new HashMap<>();
776 for (final MetadataKeyDataDefinition metadataKey : metadataKeys) {
777 if (toscaElement.getMetadata().get(metadataKey.getName()) != null) {
778 categorySpecificMetadata.put(metadataKey.getName(), (String) toscaElement.getMetadata().get(metadataKey.getName()));
779 } else if (metadataKey.getDefaultValue() != null && metadataKey.isMandatory()) {
780 categorySpecificMetadata.put(metadataKey.getName(), metadataKey.getDefaultValue());
783 component.setCategorySpecificMetadata(categorySpecificMetadata);
787 private static List<MetadataKeyDataDefinition> getCategorySpecificMetadataKeys(final ToscaElement toscaElement) {
788 final List<MetadataKeyDataDefinition> metadataKeys = new ArrayList<>();
789 final Optional<CategoryDefinition> category = getCategory(toscaElement);
790 if (category.isPresent()) {
791 if (CollectionUtils.isNotEmpty(category.get().getMetadataKeys())) {
792 metadataKeys.addAll(category.get().getMetadataKeys());
794 final Optional<SubCategoryDefinition> subCategory = getSubCategory(category.get());
795 if (subCategory.isPresent() && CollectionUtils.isNotEmpty(subCategory.get().getMetadataKeys())) {
796 metadataKeys.addAll(subCategory.get().getMetadataKeys());
802 private static Optional<CategoryDefinition> getCategory(ToscaElement toscaElement) {
803 return CollectionUtils.isEmpty(toscaElement.getCategories()) ? Optional.empty() : Optional.of(toscaElement.getCategories().get(0));
806 private static Optional<SubCategoryDefinition> getSubCategory(CategoryDefinition category) {
807 return CollectionUtils.isEmpty(category.getSubcategories()) ? Optional.empty() : Optional.of(category.getSubcategories().get(0));
810 private static NodeType convertToNodeType(Component component) {
811 Resource resource = (Resource) component;
812 NodeType nodeType = new NodeType();
813 nodeType.setDerivedFrom(resource.getDerivedFrom());
814 nodeType.setDerivedList(resource.getDerivedList());
815 nodeType.setResourceType(resource.getResourceType());
816 final String toscaVersion = resource.getToscaVersion();
817 if (toscaVersion != null) {
818 nodeType.setToscaVersion(toscaVersion);
820 final List<DataTypeDefinition> dataTypes = resource.getDataTypes();
821 if (CollectionUtils.isNotEmpty(dataTypes)) {
823 .setDataTypes(dataTypes.stream().collect(Collectors.toMap(DataTypeDefinition::getName, dataTypeDefinition -> dataTypeDefinition)));
825 convertCommonToscaData(component, nodeType);
826 convertAdditionalInformation(component, nodeType);
827 convertArtifacts(resource, nodeType);
828 convertCapabilities(resource, nodeType);
829 convertRequirements(resource, nodeType);
830 convertAttributesToNodeType(resource, nodeType);
831 convertProperties(resource, nodeType);
832 convertInterfaces(resource, nodeType);
836 private static void convertProperties(Resource resource, NodeType nodeType) {
837 List<PropertyDefinition> properties = resource.getProperties();
838 if (properties != null && !properties.isEmpty()) {
839 Map<String, PropertyDataDefinition> propertiesMap = properties.stream()
840 .collect(Collectors.toMap(PropertyDefinition::getName, PropertyDataDefinition::new));
841 nodeType.setProperties(propertiesMap);
845 private static void convertInterfaces(Resource resource, NodeType nodeType) {
846 Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
847 if (interfaces != null) {
848 Map<String, InterfaceDataDefinition> interfaceArtifacts = interfaces.entrySet().stream()
849 .collect(Collectors.toMap(Map.Entry::getKey, x -> new InterfaceDataDefinition(x.getValue())));
850 nodeType.setInterfaceArtifacts(interfaceArtifacts);
854 private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) {
855 List<AdditionalInformationDefinition> additionalInformation = component.getAdditionalInformation();
856 if (additionalInformation != null) {
857 Map<String, AdditionalInfoParameterDataDefinition> addInfo = additionalInformation.stream()
858 .collect(Collectors.toMap(AdditionalInformationDefinition::getUniqueId, AdditionalInfoParameterDataDefinition::new));
859 toscaElement.setAdditionalInformation(addInfo);
863 private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) {
864 Map<String, AdditionalInfoParameterDataDefinition> additionalInformation = toscaElement.getAdditionalInformation();
865 if (additionalInformation != null) {
866 List<AdditionalInformationDefinition> addInfo = additionalInformation.values().stream().map(AdditionalInformationDefinition::new)
867 .collect(Collectors.toList());
868 resource.setAdditionalInformation(addInfo);
872 private static void convertArtifacts(ToscaElement toscaElement, Component component) {
873 Map<String, ArtifactDataDefinition> artifacts = toscaElement.getArtifacts();
874 Map<String, ArtifactDefinition> copy;
875 if (artifacts != null) {
876 copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
878 copy = new HashMap<>();
880 component.setArtifacts(copy);
881 Map<String, ArtifactDataDefinition> toscaArtifacts = toscaElement.getToscaArtifacts();
882 if (toscaArtifacts != null) {
883 copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
885 copy = new HashMap<>();
887 component.setToscaArtifacts(copy);
888 Map<String, ArtifactDataDefinition> deploymentArtifacts = toscaElement.getDeploymentArtifacts();
889 if (deploymentArtifacts != null) {
890 copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
892 copy = new HashMap<>();
894 component.setDeploymentArtifacts(copy);
897 private static void convertNodeFiltersComponents(final TopologyTemplate topologyTemplate, final Component component) {
898 final Map<String, CINodeFilterDataDefinition> filters = topologyTemplate.getNodeFilterComponents();
899 final Map<String, CINodeFilterDataDefinition> copy;
900 if (MapUtils.isNotEmpty(filters)) {
901 copy = filters.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new CINodeFilterDataDefinition(e.getValue())));
903 copy = new HashMap<>();
905 component.setNodeFilterComponents(copy);
908 private static void convertSubstitutionFiltersComponents(final TopologyTemplate topologyTemplate, final Component component) {
909 final SubstitutionFilterDataDefinition filters = topologyTemplate.getSubstitutionFilters();
910 if (filters == null){
911 component.setSubstitutionFilter(null);
914 component.setSubstitutionFilter(new SubstitutionFilterDataDefinition(filters));
917 private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) {
918 Map<String, ArtifactDataDefinition> serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts();
919 Map<String, ArtifactDefinition> copy;
920 if (serviceApiArtifacts != null) {
921 copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
923 copy = new HashMap<>();
925 service.setServiceApiArtifacts(copy);
928 private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) {
929 Map<String, ForwardingPathDataDefinition> servicePaths = topologyTemplate.getForwardingPaths();
930 Map<String, ForwardingPathDataDefinition> copy;
931 if (servicePaths != null) {
932 copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
934 copy = new HashMap<>();
936 service.setForwardingPaths(copy);
939 private static void convertArtifacts(Component component, ToscaElement toscaElement) {
940 Map<String, ArtifactDefinition> artifacts = component.getArtifacts();
941 if (artifacts != null) {
942 Map<String, ArtifactDataDefinition> copy = artifacts.entrySet().stream()
943 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
944 toscaElement.setArtifacts(copy);
946 Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
947 if (toscaArtifacts != null) {
948 Map<String, ArtifactDataDefinition> copy = toscaArtifacts.entrySet().stream()
949 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
950 toscaElement.setToscaArtifacts(copy);
952 Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
953 if (deploymentArtifacts != null) {
954 Map<String, ArtifactDataDefinition> copy = deploymentArtifacts.entrySet().stream()
955 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
956 toscaElement.setDeploymentArtifacts(copy);
960 private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) {
961 Map<String, ArtifactDefinition> serviceApiArtifacts = service.getServiceApiArtifacts();
962 if (serviceApiArtifacts != null) {
963 Map<String, ArtifactDataDefinition> copy = serviceApiArtifacts.entrySet().stream()
964 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
965 topologyTemplate.setServiceApiArtifacts(copy);
969 private static void convertCapabilities(Component component, NodeType toscaElement) {
970 Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
971 Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
972 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
973 if (capabilities != null && !capabilities.isEmpty()) {
974 capabilities.forEach((s, caps) -> {
975 if (caps != null && !caps.isEmpty()) {
976 List<CapabilityDataDefinition> capList = caps.stream().map(CapabilityDataDefinition::new).collect(Collectors.toList());
977 populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
980 toscaElement.setCapabilities(toscaCapMap);
981 toscaElement.setCapabilitiesProperties(toscaCapPropMap);
985 private static void convertAttributesToNodeType(Resource component, NodeType nodeType) {
986 List<AttributeDefinition> attributes = component.getAttributes();
987 if (CollectionUtils.isNotEmpty(attributes)) {
988 Map<String, AttributeDataDefinition> attrsByName = attributes.stream()
989 .collect(Collectors.toMap(AttributeDefinition::getName, Function.identity()));
990 nodeType.setAttributes(attrsByName);
994 private static void convertRequirements(Resource component, NodeType nodeType) {
995 Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
996 Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
997 if (requirements != null && !requirements.isEmpty()) {
998 requirements.forEach((s, reqs) -> {
999 if (reqs != null && !reqs.isEmpty()) {
1000 List<RequirementDataDefinition> reqList = reqs.stream().map(RequirementDataDefinition::new).collect(Collectors.toList());
1001 ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
1002 toscaReqMap.put(s, listRequirementDataDefinition);
1005 nodeType.setRequirements(toscaReqMap);
1009 private static void convertCapabilities(NodeType toscaElement, Component component) {
1010 Map<String, ListCapabilityDataDefinition> toscaCapabilities = toscaElement.getCapabilities();
1011 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = toscaElement.getCapabilitiesProperties();
1012 Map<String, List<CapabilityDefinition>> capabilitiesMapFromMapObject = getCapabilitiesMapFromMapObject(toscaCapabilities, toscaCapPropMap);
1013 if (capabilitiesMapFromMapObject != null) {
1014 component.setCapabilities(capabilitiesMapFromMapObject);
1018 public static Map<String, List<CapabilityDefinition>> getCapabilitiesMapFromMapObject(Map<String, ListCapabilityDataDefinition> toscaCapabilities,
1019 Map<String, MapPropertiesDataDefinition> toscaCapPropMap) {
1020 Map<String, List<CapabilityDefinition>> compCap = new HashMap<>();
1021 if (toscaCapabilities == null || toscaCapabilities.isEmpty()) {
1024 toscaCapabilities.forEach((s, cap) -> {
1026 List<CapabilityDataDefinition> capDataList = cap.getListToscaDataDefinition();
1027 if (capDataList != null && !capDataList.isEmpty()) {
1028 List<CapabilityDefinition> capList = capDataList.stream().map(CapabilityDefinition::new).collect(Collectors.toList());
1029 compCap.put(s, capList);
1033 if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) {
1034 toscaCapPropMap.forEach((s, capProp) -> {
1035 String[] result = s.split(CAP_PROP_DELIM);
1036 if (capProp != null) {
1037 Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
1038 if (capMap != null && !capMap.isEmpty()) {
1039 List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new)
1040 .collect(Collectors.toList());
1041 List<CapabilityDefinition> cap = compCap.get(result[0]);
1042 Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
1043 op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
1051 private static void convertGroups(TopologyTemplate toscaElement, Component component) {
1052 Map<String, GroupDataDefinition> toscaGroups = toscaElement.getGroups();
1053 List<GroupDefinition> groupDefinitions = null;
1054 if (MapUtils.isNotEmpty(toscaGroups)) {
1055 groupDefinitions = toscaGroups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
1057 component.setGroups(groupDefinitions);
1060 private static void convertPolicies(TopologyTemplate toscaElement, Component component) {
1061 Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies();
1062 Map<String, PolicyDefinition> policyDefinitions = null;
1063 if (MapUtils.isNotEmpty(policies)) {
1064 policyDefinitions = policies.values().stream().map(PolicyDefinition::new)
1065 .collect(Collectors.toMap(PolicyDefinition::getUniqueId, Function.identity()));
1067 component.setPolicies(policyDefinitions);
1070 private static void convertGroups(Component component, TopologyTemplate toscaElement) {
1071 List<GroupDefinition> groupDefinitions = component.getGroups();
1072 Map<String, GroupDataDefinition> groups = new HashMap<>();
1073 if (groupDefinitions != null && groups.isEmpty()) {
1074 groups = groupDefinitions.stream().collect(Collectors.toMap(GroupDefinition::getInvariantName, GroupDefinition::new));
1076 toscaElement.setGroups(groups);
1079 private static void convertPolicies(Component component, TopologyTemplate toscaElement) {
1080 Map<String, PolicyDefinition> policyDefinitions = component.getPolicies();
1081 Map<String, PolicyDataDefinition> policies = new HashMap<>();
1082 if (MapUtils.isNotEmpty(policyDefinitions)) {
1083 policies = policyDefinitions.values().stream().collect((Collectors.toMap(PolicyDefinition::getUniqueId, PolicyDataDefinition::new)));
1085 toscaElement.setPolicies(policies);
1088 private static void convertRequirements(NodeType toscaElement, Component component) {
1089 Map<String, ListRequirementDataDefinition> toscaRequirements = toscaElement.getRequirements();
1090 Map<String, List<RequirementDefinition>> compReqs = new HashMap<>();
1091 if (toscaRequirements == null || toscaRequirements.isEmpty()) {
1094 toscaRequirements.forEach((s, req) -> {
1096 List<RequirementDataDefinition> reqDataList = req.getListToscaDataDefinition();
1097 if (reqDataList != null && !reqDataList.isEmpty()) {
1098 List<RequirementDefinition> reqList = reqDataList.stream().map(RequirementDefinition::new).collect(Collectors.toList());
1099 compReqs.put(s, reqList);
1103 component.setRequirements(compReqs);
1106 private static TopologyTemplate convertToTopologyTemplate(Component component) {
1107 TopologyTemplate topologyTemplate;
1108 ComponentTypeEnum componentType = component.getComponentType();
1109 topologyTemplate = new TopologyTemplate();
1110 if (componentType == ComponentTypeEnum.RESOURCE) {
1111 Resource resource = (Resource) component;
1112 topologyTemplate.setResourceType(resource.getResourceType());
1113 topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
1114 topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
1115 topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
1116 convertTopologyTemplateInterfaces(resource, topologyTemplate);
1118 if (componentType == ComponentTypeEnum.SERVICE) {
1119 convertServiceSpecificEntities((Service) component, topologyTemplate);
1121 convertCommonToscaData(component, topologyTemplate);
1122 convertArtifacts(component, topologyTemplate);
1123 convertAdditionalInformation(component, topologyTemplate);
1124 convertComponentInstances(component, topologyTemplate);
1125 convertInputs(component, topologyTemplate);
1126 convertProperties(component, topologyTemplate);
1127 convertAttributesToTopologyTemplate(component, topologyTemplate);
1128 convertCapabilities(component, topologyTemplate);
1129 convertGroups(component, topologyTemplate);
1130 convertPolicies(component, topologyTemplate);
1131 convertRequirements(component, topologyTemplate);
1132 convertRelationsToComposition(component, topologyTemplate);
1133 return topologyTemplate;
1136 private static void convertTopologyTemplateInterfaces(Resource resource, TopologyTemplate topologyTemplate) {
1137 Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
1138 if (interfaces != null && !interfaces.isEmpty()) {
1139 Map<String, InterfaceDataDefinition> copy = interfaces.entrySet().stream()
1140 .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue())));
1141 topologyTemplate.setInterfaces(copy);
1145 private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) {
1146 convertServiceMetaData(service, topologyTemplate);
1147 convertServiceApiArtifacts(service, topologyTemplate);
1148 convertServicePaths(service, topologyTemplate);
1149 convertServiceInterfaces(topologyTemplate, service);
1152 private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) {
1153 Map<String, ForwardingPathDataDefinition> servicePaths = service.getForwardingPaths();
1154 if (servicePaths != null && !servicePaths.isEmpty()) {
1155 Map<String, ForwardingPathDataDefinition> copy = servicePaths.entrySet().stream()
1156 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
1157 topologyTemplate.setForwardingPaths(copy);
1161 private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
1162 if (service.getDistributionStatus() != null) {
1163 topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS, service.getDistributionStatus().name());
1165 topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
1166 topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, service.isEcompGeneratedNaming());
1167 topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
1168 topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext());
1169 topologyTemplate.setMetadataValue(JsonPresentationFields.INSTANTIATION_TYPE, service.getInstantiationType());
1172 private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) {
1173 List<RequirementCapabilityRelDef> componentInstancesRelations = component.getComponentInstancesRelations();
1174 if (componentInstancesRelations != null) {
1175 Map<String, CompositionDataDefinition> compositions = topologyTemplate.getCompositions();
1176 if (compositions == null) {
1177 compositions = new HashMap<>();
1179 CompositionDataDefinition compositionDataDefinition = compositions.get(JsonConstantKeysEnum.COMPOSITION.getValue());
1180 if (compositionDataDefinition == null) {
1181 compositionDataDefinition = new CompositionDataDefinition();
1182 compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition);
1184 Map<String, RelationshipInstDataDefinition> relations = componentInstancesRelations.stream()
1185 .flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null)
1186 .collect(Collectors.toMap(RelationshipInstDataDefinition::getUniqueId, Function.identity()));
1187 compositionDataDefinition.setRelations(relations);
1191 private static void convertInputs(Component component, TopologyTemplate topologyTemplate) {
1192 List<InputDefinition> inputsList = component.getInputs();
1193 if (inputsList != null && !inputsList.isEmpty()) {
1194 Map<String, PropertyDataDefinition> inputsMap = inputsList.stream().map(PropertyDataDefinition::new)
1195 .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
1196 topologyTemplate.setInputs(inputsMap);
1200 private static void convertInputs(TopologyTemplate topologyTemplate, Component component) {
1201 Map<String, PropertyDataDefinition> inputsMap = topologyTemplate.getInputs();
1202 if (inputsMap != null && !inputsMap.isEmpty()) {
1203 List<InputDefinition> inputsList = inputsMap.values().stream().map(InputDefinition::new).collect(Collectors.toList());
1204 component.setInputs(inputsList);
1208 private static void convertOutputs(final TopologyTemplate topologyTemplate, final Component component) {
1209 final Map<String, AttributeDataDefinition> outputsMap = topologyTemplate.getOutputs();
1210 if (MapUtils.isEmpty(outputsMap)) {
1213 final List<OutputDefinition> outputList = outputsMap.values().stream().map(OutputDefinition::new).collect(Collectors.toList());
1214 component.setOutputs(outputList);
1217 private static void convertProperties(Component component, TopologyTemplate topologyTemplate) {
1218 List<PropertyDefinition> propertiesList = component.getProperties();
1219 if (propertiesList != null && !propertiesList.isEmpty()) {
1220 Map<String, PropertyDataDefinition> propertiesMap = propertiesList.stream().map(i -> new PropertyDataDefinition(i))
1221 .collect(Collectors.toMap(i -> i.getName(), i -> i));
1222 topologyTemplate.setProperties(propertiesMap);
1226 private static void convertAttributesToTopologyTemplate(final Component component, final TopologyTemplate topologyTemplate) {
1227 final List<AttributeDefinition> attributes = component.getAttributes();
1228 if (CollectionUtils.isNotEmpty(attributes)) {
1229 final Map<String, AttributeDataDefinition> attributeDataDefinitionMap = attributes.stream().map(AttributeDataDefinition::new)
1230 .collect(Collectors.toMap(AttributeDataDefinition::getName, i -> i));
1231 topologyTemplate.setAttributes(attributeDataDefinitionMap);
1235 private static void convertProperties(TopologyTemplate topologyTemplate, Component component) {
1236 Map<String, PropertyDataDefinition> propertiesMap = topologyTemplate.getProperties();
1237 if (propertiesMap != null && !propertiesMap.isEmpty()) {
1238 Map<String, PropertyDefinition> copy = propertiesMap.entrySet().stream()
1239 .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new PropertyDefinition(entry.getValue())));
1240 component.setProperties(new ArrayList<>(copy.values()));
1244 private static void convertAttributesToComponent(final TopologyTemplate topologyTemplate, final Component component) {
1245 final Map<String, AttributeDataDefinition> attributes = topologyTemplate.getAttributes();
1246 if (MapUtils.isNotEmpty(attributes)) {
1247 Map<String, AttributeDefinition> copy = attributes.entrySet().stream()
1248 .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new AttributeDefinition(entry.getValue())));
1249 component.setAttributes(new ArrayList<>(copy.values()));
1253 private static void convertDataTypes(final ToscaElement toscaElement, final Component component) {
1254 final Map<String, DataTypeDataDefinition> dataTypeDataMap = toscaElement.getDataTypes();
1255 if (MapUtils.isNotEmpty(dataTypeDataMap)) {
1256 final List<DataTypeDefinition> dataTypeDefinitionList = dataTypeDataMap.values().stream().map(dataTypeDataDefinition -> {
1257 final DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(dataTypeDataDefinition);
1258 if (CollectionUtils.isNotEmpty(dataTypeDataDefinition.getPropertiesData())) {
1259 log.debug("#convertDataTypes - propertiesData is not null. {}",
1260 ReflectionToStringBuilder.toString(dataTypeDataDefinition.getPropertiesData()));
1262 .setProperties(dataTypeDataDefinition.getPropertiesData().stream().map(PropertyDefinition::new).collect(Collectors.toList()));
1264 log.debug("#convertDataTypes - propertiesData is null. ignore.");
1266 return dataTypeDefinition;
1267 }).collect(Collectors.toList());
1268 component.setDataTypes(dataTypeDefinitionList);
1272 private static void convertCommonToscaData(Component component, ToscaElement toscaElement) {
1273 toscaElement.setUUID(component.getUUID());
1274 toscaElement.setUniqueId(component.getUniqueId());
1275 toscaElement.setSystemName(component.getSystemName());
1276 toscaElement.setLifecycleState(component.getLifecycleState());
1277 toscaElement.setComponentType(component.getComponentType());
1278 toscaElement.setNormalizedName(component.getNormalizedName());
1279 toscaElement.setMetadataValue(JsonPresentationFields.NAME, component.getName());
1280 toscaElement.setCategories(component.getCategories());
1281 toscaElement.setCreatorUserId(component.getCreatorUserId());
1282 toscaElement.setCreationDate(component.getCreationDate());
1283 toscaElement.setCreatorFullName(component.getCreatorFullName());
1284 toscaElement.setHighestVersion(component.isHighestVersion());
1285 toscaElement.setLastUpdateDate(component.getLastUpdateDate());
1286 toscaElement.setLastUpdaterFullName(component.getLastUpdaterFullName());
1287 toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId());
1288 toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType());
1289 toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion());
1291 toscaElement.setArchived(component.isArchived() == null ? false : component.isArchived());
1292 toscaElement.setArchiveTime(component.getArchiveTime() == null ? 0L : component.getArchiveTime());
1293 toscaElement.setVspArchived(component.isVspArchived() == null ? false : component.isVspArchived());
1294 toscaElement.setLifecycleState(component.getLifecycleState());
1295 toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion());
1296 if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
1297 toscaElement.setMetadataValue(JsonPresentationFields.IS_ABSTRACT, ((Resource) component).isAbstract());
1298 toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName());
1299 toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName());
1300 toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease());
1301 toscaElement.setMetadataValue(JsonPresentationFields.MODEL, component.getModel());
1302 // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1303 if (((Resource) component).getResourceVendorModelNumber() != null) {
1305 .setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber());
1307 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, "");
1309 } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
1310 // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1311 if (((Service) component).getServiceType() != null) {
1312 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType());
1314 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, "");
1316 if (((Service) component).getServiceRole() != null) {
1317 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole());
1319 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, "");
1321 if (((Service) component).getServiceFunction() != null) {
1322 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_FUNCTION, ((Service) component).getServiceFunction());
1324 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_FUNCTION, "");
1327 toscaElement.setMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL, component.getConformanceLevel());
1328 toscaElement.setMetadataValue(JsonPresentationFields.IS_DELETED, component.getIsDeleted());
1329 toscaElement.setMetadataValue(JsonPresentationFields.ICON, component.getIcon());
1330 toscaElement.setMetadataValue(JsonPresentationFields.DESCRIPTION, component.getDescription());
1331 toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags());
1332 toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID());
1333 toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
1334 toscaElement.setMetadataValue(JsonPresentationFields.MODEL, component.getModel());
1335 toscaElement.setModel(component.getModel());
1336 for (final String key : component.getCategorySpecificMetadata().keySet()) {
1337 toscaElement.setMetadataValue(key, component.getCategorySpecificMetadata().get(key));
1339 final List<DataTypeDefinition> dataTypes = component.getDataTypes();
1340 if (CollectionUtils.isNotEmpty(dataTypes)) {
1342 .setDataTypes(dataTypes.stream().collect(Collectors.toMap(DataTypeDefinition::getName, dataTypeDefinition -> dataTypeDefinition)));
1346 private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {
1347 List<ComponentInstance> componentInstances = new ArrayList<>();
1348 ComponentInstance currComponentInstance;
1349 Map<String, CINodeFilterDataDefinition> nodeFilterComponents = topologyTemplate.getNodeFilterComponents();
1350 for (Map.Entry<String, ComponentInstanceDataDefinition> entry : topologyTemplate.getComponentInstances().entrySet()) {
1351 String key = entry.getKey();
1352 currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key));
1353 if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) {
1354 List<GroupInstance> groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream()
1355 .map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList());
1356 currComponentInstance.setGroupInstances(groupInstances);
1358 setComponentInstanceSource(currComponentInstance, component);
1359 if (MapUtils.isNotEmpty(nodeFilterComponents) && nodeFilterComponents.containsKey(key)) {
1360 currComponentInstance.setNodeFilter(nodeFilterComponents.get(key));
1362 if (topologyTemplate.getInstProperties() != null && topologyTemplate.getInstProperties().containsKey(key)
1363 && topologyTemplate.getInstProperties().get(key) != null) {
1364 List<PropertyDefinition> instanceProps = topologyTemplate.getInstProperties().get(key).getMapToscaDataDefinition().entrySet().stream()
1365 .map(e -> new PropertyDefinition(e.getValue())).collect(Collectors.toList());
1366 currComponentInstance.setProperties(instanceProps);
1368 if (topologyTemplate.getInstInputs() != null && topologyTemplate.getInstInputs().containsKey(key)
1369 && topologyTemplate.getInstInputs().get(key) != null) {
1370 List<InputDefinition> instanceInputs = topologyTemplate.getInstInputs().get(key).getMapToscaDataDefinition().entrySet().stream()
1371 .map(e -> new InputDefinition(e.getValue())).collect(Collectors.toList());
1372 currComponentInstance.setInputs(instanceInputs);
1374 final Map<String, MapAttributesDataDefinition> instAttributes = topologyTemplate.getInstAttributes();
1375 if (instAttributes != null && instAttributes.containsKey(key) && instAttributes.get(key) != null) {
1376 currComponentInstance.setAttributes(
1377 instAttributes.get(key).getMapToscaDataDefinition().values().stream().map(AttributeDefinition::new).collect(Collectors.toList()));
1379 if (topologyTemplate.getComponentInstInterfaces() != null && topologyTemplate.getComponentInstInterfaces().containsKey(key)
1380 && topologyTemplate.getComponentInstInterfaces().get(key) != null) {
1381 Map<String, Object> interfacesMap = topologyTemplate.getComponentInstInterfaces().get(key).getMapToscaDataDefinition().entrySet()
1382 .stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
1383 currComponentInstance.setInterfaces(interfacesMap);
1385 componentInstances.add(currComponentInstance);
1387 component.setComponentInstances(componentInstances);
1390 public static List<ComponentInstance> getComponentInstancesFromMapObject(
1391 Map<String, ComponentInstanceDataDefinition> componentInstancesDefinitionMap, Component component) {
1392 List<ComponentInstance> componentInstances = new ArrayList<>();
1393 ComponentInstance currComponentInstance;
1394 for (Map.Entry<String, ComponentInstanceDataDefinition> entry : componentInstancesDefinitionMap.entrySet()) {
1395 String key = entry.getKey();
1396 currComponentInstance = new ComponentInstance(componentInstancesDefinitionMap.get(key));
1397 setComponentInstanceSource(currComponentInstance, component);
1398 componentInstances.add(currComponentInstance);
1400 return componentInstances;
1403 private static void setComponentInstanceSource(ComponentInstance currComponentInstance, Component component) {
1404 if (Objects.isNull(currComponentInstance.getCreatedFrom())) {
1405 if (ComponentTypeEnum.RESOURCE.equals(component.getComponentType())) {
1406 Resource resource = (Resource) component;
1407 if (isFromCsar(resource)) {
1408 currComponentInstance.setCreatedFrom(CreatedFrom.CSAR);
1410 currComponentInstance.setCreatedFrom(CreatedFrom.UI);
1416 private static boolean isFromCsar(Resource resource) {
1417 return resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.CVFC
1418 || resource.getResourceType() == ResourceTypeEnum.PNF;
1421 private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) {
1422 if (topologyTemplate.getInstInputs() != null) {
1423 Map<String, List<ComponentInstanceInput>> inputs = new HashMap<>();
1424 for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstInputs().entrySet()) {
1425 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1426 String key = entry.getKey();
1427 List<ComponentInstanceInput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1428 .map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList());
1429 inputs.put(key, componentInstanceAttributes);
1432 component.setComponentInstancesInputs(inputs);
1436 private static void setComponentInstancesOutputsToComponent(final TopologyTemplate topologyTemplate, final Component component) {
1437 if (topologyTemplate.getInstOutputs() != null) {
1438 final Map<String, List<ComponentInstanceOutput>> outputs = new HashMap<>();
1439 for (final Entry<String, MapAttributesDataDefinition> entry : topologyTemplate.getInstOutputs().entrySet()) {
1440 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1441 final String key = entry.getKey();
1442 final List<ComponentInstanceOutput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1443 .map(e -> new ComponentInstanceOutput(e.getValue())).collect(Collectors.toList());
1444 outputs.put(key, componentInstanceAttributes);
1447 component.setComponentInstancesOutputs(outputs);
1451 private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) {
1452 if (topologyTemplate.getInstProperties() != null) {
1453 Map<String, List<ComponentInstanceProperty>> properties = new HashMap<>();
1454 for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstProperties().entrySet()) {
1455 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1456 String key = entry.getKey();
1457 List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1458 .map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue()))).collect(Collectors.toList());
1459 properties.put(key, componentInstanceAttributes);
1462 component.setComponentInstancesProperties(properties);
1466 public static Map<String, List<ComponentInstanceAttribute>> getComponentInstancesAttributes(
1467 Map<String, MapAttributesDataDefinition> mapAttributesDataDefinitionMap) {
1468 Map<String, List<ComponentInstanceAttribute>> attributes = new HashMap<>();
1469 for (Map.Entry<String, MapAttributesDataDefinition> entry : mapAttributesDataDefinitionMap.entrySet()) {
1470 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1471 String key = entry.getKey();
1472 List<ComponentInstanceAttribute> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1473 .map(e -> new ComponentInstanceAttribute(new AttributeDefinition(e.getValue()))).collect(Collectors.toList());
1474 attributes.put(key, componentInstanceAttributes);
1480 private static void setComponentInstancesInterfacesToComponent(TopologyTemplate topologyTemplate, Component component) {
1481 if (topologyTemplate.getInstInterfaces() != null) {
1482 Map<String, List<ComponentInstanceInterface>> interfaces = new HashMap<>();
1483 for (Map.Entry<String, MapInterfaceInstanceDataDefinition> entry : topologyTemplate.getInstInterfaces().entrySet()) {
1484 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1485 String key = entry.getKey();
1486 List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1487 .map(e -> new ComponentInstanceInterface(e.getKey(), e.getValue())).collect(Collectors.toList());
1488 interfaces.put(key, componentInstanceInterfaces);
1491 component.setComponentInstancesInterfaces(interfaces);
1492 } else if (topologyTemplate.getComponentInstInterfaces() != null) {
1493 Map<String, List<ComponentInstanceInterface>> interfaces = new HashMap<>();
1494 for (Map.Entry<String, MapInterfaceDataDefinition> entry : topologyTemplate.getComponentInstInterfaces().entrySet()) {
1495 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1496 String key = entry.getKey();
1497 List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1498 .map(e -> new ComponentInstanceInterface(e.getKey(), e.getValue())).collect(Collectors.toList());
1499 interfaces.put(key, componentInstanceInterfaces);
1502 component.setComponentInstancesInterfaces(interfaces);
1506 private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) {
1507 if (topologyTemplate.getInstAttributes() != null) {
1508 Map<String, List<ComponentInstanceAttribute>> attributes = new HashMap<>();
1509 for (Map.Entry<String, MapAttributesDataDefinition> entry : topologyTemplate.getInstAttributes().entrySet()) {
1510 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1511 String key = entry.getKey();
1512 List<ComponentInstanceAttribute> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1513 .map(e -> new ComponentInstanceAttribute(new AttributeDefinition(e.getValue()))).collect(Collectors.toList());
1514 attributes.put(key, componentInstanceAttributes);
1517 component.setComponentInstancesAttributes(attributes);
1521 public static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
1522 if (topologyTemplate.getCalculatedRequirements() != null) {
1523 // Requirements of component organized by capability
1524 Map<String, List<RequirementDefinition>> instanceRequiermentsFromMapObject = getInstanceRequirementsFromMapObject(
1525 topologyTemplate.getCalculatedRequirements(), component);
1526 component.setRequirements(instanceRequiermentsFromMapObject);
1530 public static Map<String, List<RequirementDefinition>> getInstanceRequirementsFromMapObject(
1531 Map<String, MapListRequirementDataDefinition> mapListRequirements, Component component) {
1532 // Requirements of component organized by capability
1533 Map<String, List<RequirementDefinition>> instancesRequirements = new HashMap<>();
1534 if (mapListRequirements != null) {
1535 Map<String, ComponentInstance> instancesMap = new HashMap<>();
1536 for (ComponentInstance currInstance : component.getComponentInstances()) {
1537 instancesMap.put(currInstance.getUniqueId(), currInstance);
1539 for (Map.Entry<String, MapListRequirementDataDefinition> entry : mapListRequirements.entrySet()) {
1540 String instanceId = entry.getKey();
1541 // Requirements of instance organized by capability
1542 Map<String, ListRequirementDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1543 if (capsMapList != null) {
1544 for (Entry<String, ListRequirementDataDefinition> entryTypeList : capsMapList.entrySet()) {
1545 String capabilityType = entryTypeList.getKey();
1546 List<RequirementDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
1547 .map(RequirementDefinition::new).collect(Collectors.toList());
1548 if (instancesRequirements.containsKey(capabilityType)) {
1549 instancesRequirements.get(capabilityType).addAll(caps);
1551 instancesRequirements.put(capabilityType, caps);
1553 if (MapUtils.isEmpty(instancesMap.get(instanceId).getRequirements())) {
1554 instancesMap.get(instanceId).setRequirements(new HashMap<>());
1556 instancesMap.get(instanceId).getRequirements().put(capabilityType, new ArrayList<>(caps));
1560 component.setRequirements(instancesRequirements);
1562 return instancesRequirements;
1565 public static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) {
1566 Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1567 if (topologyTemplate.getCalculatedCapabilities() != null) {
1568 // capabilities of component organized by type
1569 Map<String, List<CapabilityDefinition>> instancesCapabilities = new HashMap<>();
1570 Map<String, ComponentInstance> instancesMap = new HashMap<>();
1571 for (ComponentInstance currInstance : component.getComponentInstances()) {
1572 instancesMap.put(currInstance.getUniqueId(), currInstance);
1574 for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1575 String instanceId = entry.getKey();
1576 // capabilities of instance organized by type
1577 Map<String, ListCapabilityDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1578 if (capsMapList != null) {
1579 for (Entry<String, ListCapabilityDataDefinition> entryTypeList : capsMapList.entrySet()) {
1580 String capabilityType = entryTypeList.getKey();
1581 List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
1582 .map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList());
1583 if (instancesCapabilities.containsKey(capabilityType)) {
1584 instancesCapabilities.get(capabilityType).addAll(caps);
1586 instancesCapabilities.put(capabilityType, caps);
1588 ComponentInstance instance = instancesMap.get(instanceId);
1589 if (instance == null) {
1590 log.error("instance is null for id {} entry {}", instanceId,
1591 entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME));
1593 if (MapUtils.isEmpty(instance.getCapabilities())) {
1594 instance.setCapabilities(new HashMap<>());
1596 instance.getCapabilities().put(capabilityType, new ArrayList<>(caps));
1601 component.setCapabilities(instancesCapabilities);
1605 private static void setCapabilitiesToComponent(TopologyTemplate topologyTemplate, Component component) {
1606 Map<String, ListCapabilityDataDefinition> capabilities = topologyTemplate.getCapabilities();
1607 Map<String, MapPropertiesDataDefinition> capabilitiesProperties = topologyTemplate.getCapabilitiesProperties();
1608 Map<String, List<CapabilityDefinition>> allCapabilities = new HashMap<>();
1609 if (MapUtils.isNotEmpty(capabilities)) {
1610 allCapabilities.putAll(groupCapabilityByType(capabilities));
1612 if (MapUtils.isNotEmpty(capabilitiesProperties)) {
1613 capabilitiesProperties.forEach((s, capProp) -> {
1614 String[] result = s.split(CAP_PROP_DELIM);
1615 if (capProp != null) {
1616 Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
1617 if (MapUtils.isNotEmpty(capMap)) {
1618 List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new)
1619 .collect(Collectors.toList());
1620 List<CapabilityDefinition> cap = allCapabilities.get(result[0]);
1622 Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
1623 op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
1629 Map<String, List<CapabilityDefinition>> componentCapabilities = component.getCapabilities();
1630 if (MapUtils.isNotEmpty(componentCapabilities)) {
1631 mergeCapabilityMap(allCapabilities, componentCapabilities);
1633 component.setCapabilities(allCapabilities);
1636 private static void mergeCapabilityMap(Map<String, List<CapabilityDefinition>> map1, Map<String, List<CapabilityDefinition>> map2) {
1637 map1.forEach((key1, val1) -> map2.forEach((key2, val2) -> {
1638 if (key1.equals(key2)) {
1645 private static Map<String, List<CapabilityDefinition>> groupCapabilityByType(Map<String, ListCapabilityDataDefinition> capabilities) {
1646 Map<String, List<CapabilityDefinition>> groupedCapabilities = new HashMap<>();
1647 Set<String> typesSet = new HashSet<>();
1648 List<CapabilityDefinition> allCapabilityDefinitions = new ArrayList<>();
1649 for (Entry<String, ListCapabilityDataDefinition> capabilitiesEntry : capabilities.entrySet()) {
1650 typesSet.addAll(capabilitiesEntry.getValue().getListToscaDataDefinition().stream().map(CapabilityDataDefinition::getType)
1651 .collect(Collectors.toSet()));
1652 allCapabilityDefinitions.addAll(
1653 capabilitiesEntry.getValue().getListToscaDataDefinition().stream().map(CapabilityDefinition::new).collect(Collectors.toList()));
1655 for (String capType : typesSet) {
1656 groupedCapabilities.put(capType,
1657 allCapabilityDefinitions.stream().filter(capabilityDefinition -> capabilityDefinition.getType().equals(capType))
1658 .collect(Collectors.toList()));
1660 return groupedCapabilities;
1663 private static void setRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
1664 Map<String, ListRequirementDataDefinition> requirements = topologyTemplate.getRequirements();
1665 Map<String, List<RequirementDefinition>> componentRequirements = component.getRequirements();
1666 if (MapUtils.isNotEmpty(requirements)) {
1667 if (componentRequirements == null) {
1668 componentRequirements = new HashMap<>();
1670 componentRequirements.putAll(groupRequirementByType(requirements));
1671 component.setRequirements(componentRequirements);
1675 private static Map<String, List<RequirementDefinition>> groupRequirementByType(Map<String, ListRequirementDataDefinition> requirements) {
1676 Map<String, List<RequirementDefinition>> groupedRequirement = new HashMap<>();
1677 Set<String> typesSet = new HashSet<>();
1678 List<RequirementDefinition> allRequirements = new ArrayList<>();
1679 for (Entry<String, ListRequirementDataDefinition> requirementsEntry : requirements.entrySet()) {
1680 typesSet.addAll(requirementsEntry.getValue().getListToscaDataDefinition().stream().map(RequirementDataDefinition::getCapability)
1681 .collect(Collectors.toSet()));
1682 allRequirements.addAll(
1683 requirementsEntry.getValue().getListToscaDataDefinition().stream().map(RequirementDefinition::new).collect(Collectors.toList()));
1685 for (String capType : typesSet) {
1686 groupedRequirement.put(capType,
1687 allRequirements.stream().filter(requirementDefinition -> requirementDefinition.getCapability().equals(capType))
1688 .collect(Collectors.toList()));
1690 return groupedRequirement;
1693 private static void setCapabilitiesToComponentAndGroups(TopologyTemplate topologyTemplate, Component component) {
1694 Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1695 if (capabilitiesAndGroupsExist(topologyTemplate, component)) {
1696 Map<String, GroupDefinition> groupsMap = component.getGroups().stream()
1697 .collect(Collectors.toMap(GroupDefinition::getUniqueId, Function.identity()));
1698 for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1699 findSetCapabilitiesToComponentAndGroup(calculatedCapProperties, component, groupsMap, entry);
1704 private static boolean capabilitiesAndGroupsExist(TopologyTemplate topologyTemplate, Component component) {
1705 return MapUtils.isNotEmpty(topologyTemplate.getCalculatedCapabilities()) && CollectionUtils.isNotEmpty(component.getGroups());
1708 private static void findSetCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component,
1709 Map<String, GroupDefinition> groupsMap,
1710 Map.Entry<String, MapListCapabilityDataDefinition> entry) {
1711 String uniqueId = entry.getKey();
1712 if (groupsMap.containsKey(uniqueId)) {
1713 setCapabilitiesToComponentAndGroup(calculatedCapProperties, component, entry, groupsMap.get(uniqueId));
1715 log.warn("The group with uniqueId {} was not found", uniqueId);
1719 private static void setCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component,
1720 Map.Entry<String, MapListCapabilityDataDefinition> entry, GroupDefinition group) {
1721 for (Entry<String, ListCapabilityDataDefinition> entryTypeList : entry.getValue().getMapToscaDataDefinition().entrySet()) {
1722 String capabilityType = entryTypeList.getKey();
1723 List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
1724 .map(cap -> mergeInstCapabiltyWithProperty(cap, group.getUniqueId(), calculatedCapProperties)).collect(Collectors.toList());
1725 if (component.getCapabilities().containsKey(capabilityType)) {
1726 component.getCapabilities().get(capabilityType).addAll(caps);
1728 component.getCapabilities().put(capabilityType, caps);
1730 group.getCapabilities().put(capabilityType, Lists.newArrayList(caps));
1734 private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String ownerId,
1735 Map<String, MapCapabilityProperty> calculatedCapProperties) {
1736 CapabilityDefinition capability = new CapabilityDefinition(cap);
1737 if (calculatedCapProperties != null) {
1738 MapCapabilityProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(ownerId);
1739 if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) {
1740 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition();
1741 toscaCapPropMap.forEach((keyPath, capProp) -> findConvertSetProperties(cap, ownerId, capability, keyPath, capProp));
1747 private static void findConvertSetProperties(CapabilityDataDefinition cap, String primaryPathKey, CapabilityDefinition capability, String path,
1748 MapPropertiesDataDefinition capProp) {
1749 // format key of capability properties :
1751 // VF instance in service : instanceId#ownerId#type#capName
1753 // VFC instance in VF : instanceId#type#capName -> instanceId=ownerId
1755 // Group in service : groupName#ownerId#type#capName
1757 // Group in VF : groupName#type#capName -> groupName=ownerId
1758 String[] result = path.split(CAP_PROP_DELIM);
1759 if (result.length < 4) {
1760 log.debug("wrong key format for capabilty, key {}", capProp);
1763 if (relatedPropertiesExist(cap, primaryPathKey, capProp, result)) {
1764 capability.setProperties(
1765 capProp.getMapToscaDataDefinition().values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()));
1769 private static boolean relatedPropertiesExist(CapabilityDataDefinition cap, String primaryPathKey, MapPropertiesDataDefinition capProp,
1771 return capProp != null && MapUtils.isNotEmpty(capProp.getMapToscaDataDefinition()) && areRelatedProperties(cap, primaryPathKey, result);
1774 private static boolean areRelatedProperties(CapabilityDataDefinition cap, String primaryPathKey, String[] result) {
1775 int primaryKeyIndex = 0;
1777 int typeIndex = result.length - 2;
1778 int nameIndex = result.length - 1;
1779 return result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex])
1780 && primaryPathKey.equals(result[primaryKeyIndex]);
1783 private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1784 Map<String, ComponentInstanceDataDefinition> componentInstances = new HashMap<>();
1785 ComponentInstanceDataDefinition convertedInstance;
1786 if (component.getComponentInstances() != null) {
1787 for (ComponentInstance instance : component.getComponentInstances()) {
1788 convertedInstance = new ComponentInstanceDataDefinition(instance);
1789 if (instance.getGroupInstances() != null) {
1790 MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition();
1791 groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(GroupInstanceDataDefinition::new)
1792 .collect(Collectors.toMap(GroupInstanceDataDefinition::getName, Function.identity())));
1793 if (topologyTemplate.getInstGroups() == null) {
1794 topologyTemplate.setInstGroups(new HashMap<>());
1796 topologyTemplate.getInstGroups().put(instance.getUniqueId(), groupsMap);
1798 componentInstances.put(instance.getUniqueId(), convertedInstance);
1801 topologyTemplate.setComponentInstances(componentInstances);
1804 private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1805 if (component.getComponentInstancesInputs() != null) {
1806 topologyTemplate.setInstInputs(new HashMap<>());
1807 MapPropertiesDataDefinition inputsMap;
1808 for (Entry<String, List<ComponentInstanceInput>> entry : component.getComponentInstancesInputs().entrySet()) {
1809 inputsMap = new MapPropertiesDataDefinition();
1810 inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new)
1811 .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
1812 topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap);
1817 private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1818 if (component.getComponentInstancesProperties() != null) {
1819 topologyTemplate.setInstProperties(new HashMap<>());
1820 MapPropertiesDataDefinition propertiesMap;
1821 for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesProperties().entrySet()) {
1822 propertiesMap = new MapPropertiesDataDefinition();
1823 propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new)
1824 .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
1825 topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap);
1830 private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1831 List<ComponentInstance> componentInstances = component.getComponentInstances();
1832 if (componentInstances != null) {
1833 topologyTemplate.setInstanceArtifacts(new HashMap<>());
1834 topologyTemplate.setInstDeploymentArtifacts(new HashMap<>());
1835 for (ComponentInstance ci : componentInstances) {
1836 Map<String, ArtifactDefinition> artifacts = ci.getArtifacts();
1837 if (artifacts != null) {
1838 Map<String, ArtifactDataDefinition> mapToscaDataDefinitionArtifact = artifacts.entrySet().stream()
1839 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1840 MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact);
1841 topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact);
1843 Map<String, ArtifactDefinition> deplArtifacts = ci.getDeploymentArtifacts();
1844 if (deplArtifacts != null) {
1845 Map<String, ArtifactDataDefinition> mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream()
1846 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1847 MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact);
1848 topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact);
1854 private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1855 if (component.getComponentInstancesAttributes() != null) {
1856 topologyTemplate.setInstAttributes(new HashMap<>());
1857 for (Entry<String, List<ComponentInstanceAttribute>> entry : component.getComponentInstancesAttributes().entrySet()) {
1858 final MapAttributesDataDefinition attributesMap = new MapAttributesDataDefinition();
1859 attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(AttributeDefinition::new)
1860 .collect(Collectors.toMap(AttributeDefinition::getName, Function.identity(), (entity1, entity2) -> entity1)));
1861 topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap);
1866 public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) {
1867 ComponentMetadataData metadata;
1868 switch (vertex.getType()) {
1870 metadata = new ServiceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
1873 metadata = new ResourceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
1876 metadata = new ProductMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
1879 throw new StorageException(JanusGraphOperationStatus.INVALID_TYPE);
1881 metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId());
1882 metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
1883 metadata.getMetadataDataDefinition().setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID));
1884 metadata.getMetadataDataDefinition().setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE));
1888 public static ComponentMetadataDataDefinition convertToComponentMetadataDataDefinition(GraphVertex vertex) {
1889 ComponentMetadataDataDefinition metadata;
1890 switch (vertex.getType()) {
1892 metadata = new ServiceMetadataDataDefinition(new JsonPresentationFieldsExtractor(vertex.getMetadataJson()));
1895 metadata = new ResourceMetadataDataDefinition(new JsonPresentationFieldsExtractor(vertex.getMetadataJson()));
1898 metadata = new ProductMetadataDataDefinition(new JsonPresentationFieldsExtractor(vertex.getMetadataJson()));
1901 throw new StorageException(JanusGraphOperationStatus.INVALID_TYPE);
1903 metadata.setUniqueId(vertex.getUniqueId());
1904 metadata.setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
1905 metadata.setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID));
1906 metadata.setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE));
1910 public static List<GroupDefinition> convertToGroupDefinitions(Map<String, GroupDataDefinition> groups) {
1911 List<GroupDefinition> groupDefinitions = new ArrayList<>();
1912 if (MapUtils.isNotEmpty(groups)) {
1913 groupDefinitions = groups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
1915 return groupDefinitions;
1918 public static Map<String, MapCapabilityProperty> extractCapabilityProperteisFromInstances(List<ComponentInstance> instances, boolean fromCsar) {
1919 return instances.stream().collect(Collectors.toMap(ComponentInstanceDataDefinition::getUniqueId,
1920 ci -> convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), ci.getUniqueId(), fromCsar)));
1923 public static Map<String, MapCapabilityProperty> extractCapabilityPropertiesFromGroups(List<GroupDefinition> groups, boolean fromCsar) {
1924 if (CollectionUtils.isNotEmpty(groups)) {
1925 return groups.stream().collect(Collectors
1926 .toMap(GroupDefinition::getUniqueId, g -> convertToMapOfMapCapabiltyProperties(g.getCapabilities(), g.getUniqueId(), fromCsar)));
1928 return Maps.newHashMap();
1931 public static Map<String, MapListCapabilityDataDefinition> extractCapabilitiesFromGroups(final List<GroupDefinition> groupDefinitions) {
1932 Map<String, MapListCapabilityDataDefinition> calculatedCapabilities = Maps.newHashMap();
1933 for (GroupDefinition groupDefinition : groupDefinitions) {
1934 calculatedCapabilities
1935 .put(groupDefinition.getUniqueId(), new MapListCapabilityDataDefinition(buildMapOfListsOfCapabilities(groupDefinition)));
1937 return calculatedCapabilities;
1940 private static Map<String, ListCapabilityDataDefinition> buildMapOfListsOfCapabilities(GroupDefinition groupDefinition) {
1941 return groupDefinition.getCapabilities().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,
1942 e -> new ListCapabilityDataDefinition(e.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))));