Service Import - Node Template Relationship Template
[sdc.git] / catalog-model / src / main / java / org / openecomp / sdc / be / model / jsonjanusgraph / utils / ModelConverter.java
1 /*-
2  * ============LICENSE_START=======================================================
3  * SDC
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
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
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=========================================================
19  */
20 package org.openecomp.sdc.be.model.jsonjanusgraph.utils;
21
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;
30 import java.util.Map;
31 import java.util.Map.Entry;
32 import java.util.Objects;
33 import java.util.Optional;
34 import java.util.Set;
35 import java.util.UUID;
36 import java.util.function.Function;
37 import java.util.stream.Collectors;
38 import org.apache.commons.collections.CollectionUtils;
39 import org.apache.commons.collections.MapUtils;
40 import org.apache.commons.lang3.BooleanUtils;
41 import org.apache.commons.lang3.StringUtils;
42 import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
43 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
44 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
45 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
46 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionaryExtractor;
47 import org.openecomp.sdc.be.datatypes.category.MetadataKeyDataDefinition;
48 import org.openecomp.sdc.be.datatypes.components.ComponentMetadataDataDefinition;
49 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
50 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
51 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
52 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
53 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
54 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
55 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
56 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
57 import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
58 import org.openecomp.sdc.be.datatypes.elements.DataTypeDataDefinition;
59 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
60 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
61 import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
62 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
63 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
64 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
65 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.MapAttributesDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
69 import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.MapInterfaceDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
76 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
77 import org.openecomp.sdc.be.datatypes.elements.ProductMetadataDataDefinition;
78 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
79 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
80 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
81 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterDataDefinition;
82 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
83 import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
84 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
85 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFieldsExtractor;
86 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
87 import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
88 import org.openecomp.sdc.be.model.ArtifactDefinition;
89 import org.openecomp.sdc.be.model.AttributeDefinition;
90 import org.openecomp.sdc.be.model.CapabilityDefinition;
91 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
92 import org.openecomp.sdc.be.model.Component;
93 import org.openecomp.sdc.be.model.ComponentInstance;
94 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
95 import org.openecomp.sdc.be.model.ComponentInstanceInput;
96 import org.openecomp.sdc.be.model.ComponentInstanceInterface;
97 import org.openecomp.sdc.be.model.ComponentInstanceOutput;
98 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
99 import org.openecomp.sdc.be.model.DataTypeDefinition;
100 import org.openecomp.sdc.be.model.DistributionStatusEnum;
101 import org.openecomp.sdc.be.model.GroupDefinition;
102 import org.openecomp.sdc.be.model.GroupInstance;
103 import org.openecomp.sdc.be.model.InputDefinition;
104 import org.openecomp.sdc.be.model.InterfaceDefinition;
105 import org.openecomp.sdc.be.model.MapInterfaceInstanceDataDefinition;
106 import org.openecomp.sdc.be.model.OutputDefinition;
107 import org.openecomp.sdc.be.model.PolicyDefinition;
108 import org.openecomp.sdc.be.model.PropertyDefinition;
109 import org.openecomp.sdc.be.model.RelationshipImpl;
110 import org.openecomp.sdc.be.model.RelationshipInfo;
111 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
112 import org.openecomp.sdc.be.model.RequirementDefinition;
113 import org.openecomp.sdc.be.model.Resource;
114 import org.openecomp.sdc.be.model.Service;
115 import org.openecomp.sdc.be.model.category.CategoryDefinition;
116 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
117 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.NodeType;
118 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.TopologyTemplate;
119 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
120 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElementTypeEnum;
121 import org.openecomp.sdc.be.model.jsonjanusgraph.enums.JsonConstantKeysEnum;
122 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation;
123 import org.openecomp.sdc.be.model.operations.StorageException;
124 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
125 import org.openecomp.sdc.be.resources.data.ProductMetadataData;
126 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
127 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
128 import org.openecomp.sdc.be.ui.model.OperationUi;
129 import org.openecomp.sdc.be.ui.model.PropertyAssignmentUi;
130 import org.openecomp.sdc.common.log.wrappers.Logger;
131
132 public class ModelConverter {
133
134     public static final String CAP_PROP_DELIM = "#";
135     private static final Logger log = Logger.getLogger(ModelConverter.class);
136
137     private ModelConverter() {
138     }
139
140     @SuppressWarnings("unchecked")
141     public static <T extends ToscaElement> T convertToToscaElement(Component component) {
142         if (isAtomicComponent(component)) {
143             return (T) convertToNodeType(component);
144         }
145         return (T) convertToTopologyTemplate(component);
146     }
147
148     @SuppressWarnings("unchecked")
149     public static <T extends Component> T convertFromToscaElement(ToscaElement toscaElement) {
150         switch (toscaElement.getComponentType()) {
151             case RESOURCE:
152                 return (T) convertToResource(toscaElement);
153             case SERVICE:
154             case PRODUCT:
155                 return (T) convertToService(toscaElement);
156             default:
157                 return null;
158         }
159     }
160
161     public static boolean isAtomicComponent(Component component) {
162         ComponentTypeEnum componentType = component.getComponentType();
163         if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
164             return false;
165         }
166         Resource resource = (Resource) component;
167         ResourceTypeEnum resType = resource.getResourceType();
168         return isAtomicComponent(resType);
169     }
170
171     public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
172         if (resourceType == null) {
173             return false;
174         }
175         return resourceType.isAtomicType();
176     }
177
178     // **********************************************************
179     public static VertexTypeEnum getVertexType(Component component) {
180         VertexTypeEnum vertexType;
181         if (isAtomicComponent(component)) {
182             vertexType = VertexTypeEnum.NODE_TYPE;
183         } else {
184             vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
185         }
186         return vertexType;
187     }
188
189     public static VertexTypeEnum getVertexType(String resourceTypeName) {
190         ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName);
191         if (isAtomicComponent(resourceType)) {
192             return VertexTypeEnum.NODE_TYPE;
193         } else {
194             return VertexTypeEnum.TOPOLOGY_TEMPLATE;
195         }
196     }
197
198     private static Service convertToService(ToscaElement toscaElement) {
199         Service service = new Service();
200         convertComponentFields(service, toscaElement);
201         convertServiceSpecificFields(toscaElement, service);
202         TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
203         convertComponentInstances(topologyTemplate, service);
204         convertInputs(topologyTemplate, service);
205         convertOutputs(topologyTemplate, service);
206         convertProperties(topologyTemplate, service);
207         convertPolicies(topologyTemplate, service);
208         convertAttributesToComponent(topologyTemplate, service);
209         convertGroups(topologyTemplate, service);
210         setCapabilitiesToComponentAndGroups(topologyTemplate, service);
211         convertPolicies(topologyTemplate, service);
212         convertRelations(topologyTemplate, service);
213         convertArtifacts(topologyTemplate, service);
214         convertServiceApiArtifacts(topologyTemplate, service);
215         convertServicePaths(topologyTemplate, service);
216         convertServiceInterfaces(topologyTemplate, service);
217         convertDataTypes(topologyTemplate, service);
218         convertNodeFiltersComponents(topologyTemplate, service);
219         convertSubstitutionFiltersComponents(topologyTemplate, service);
220         setCapabilitiesToComponent(topologyTemplate, service);
221         setRequirementsToComponent(topologyTemplate, service);
222         return service;
223     }
224
225     private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) {
226         service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE));
227         service.setDistributionStatus(
228             DistributionStatusEnum.findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
229         service.setEcompGeneratedNaming((Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
230         service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, StringUtils.EMPTY));
231         service.setEnvironmentContext((String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT));
232         service.setInstantiationType((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.INSTANTIATION_TYPE, StringUtils.EMPTY));
233     }
234
235     private static Resource convertToResource(ToscaElement toscaElement) {
236         Resource resource = new Resource();
237         convertComponentFields(resource, toscaElement);
238         resource.setResourceType(toscaElement.getResourceType());
239         if (toscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) {
240             NodeType nodeType = (NodeType) toscaElement;
241             resource.setDerivedFrom(nodeType.getDerivedFrom());
242             resource.setDerivedList(nodeType.getDerivedList());
243             resource.setDerivedFromMapOfIdToName(nodeType.getDerivedFromMapOfIdToName());
244             resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
245             final String toscaVersion = nodeType.getToscaVersion();
246             if (toscaVersion != null) {
247                 resource.setToscaVersion(toscaVersion);
248             }
249             convertAttributesToResource(nodeType, resource);
250             convertCapabilities(nodeType, resource);
251             convertRequirements(nodeType, resource);
252             convertInterfaces(nodeType, resource);
253             convertDataTypes(nodeType, resource);
254         } else {
255             TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
256             if (resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.PNF) {
257                 resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
258                 resource.setCsarVersionId((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION_ID));
259                 resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
260                 resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
261                 convertInterfaces(topologyTemplate, resource);
262             }
263             convertComponentInstances(topologyTemplate, resource);
264             convertRelations(topologyTemplate, resource);
265             convertInputs(topologyTemplate, resource);
266             convertOutputs(topologyTemplate, resource);
267             convertGroups(topologyTemplate, resource);
268             setCapabilitiesToComponentAndGroups(topologyTemplate, resource);
269             convertPolicies(topologyTemplate, resource);
270             convertNodeFiltersComponents(topologyTemplate, resource);
271             convertSubstitutionFiltersComponents(topologyTemplate, resource);
272             convertProperties(topologyTemplate, resource);
273             convertAttributesToComponent(topologyTemplate, resource);
274             setCapabilitiesToComponent(topologyTemplate, resource);
275             setRequirementsToComponent(topologyTemplate, resource);
276             convertDataTypes(topologyTemplate, resource);
277         }
278         convertArtifacts(toscaElement, resource);
279         convertAdditionalInformation(toscaElement, resource);
280         return resource;
281     }
282
283     private static void convertInterfaces(TopologyTemplate toscaElement, Resource resource) {
284         Map<String, InterfaceDataDefinition> interfaces = toscaElement.getInterfaces();
285         Map<String, InterfaceDefinition> copy;
286         if (interfaces != null) {
287             copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue())));
288         } else {
289             copy = new HashMap<>();
290         }
291         resource.setInterfaces(copy);
292     }
293
294     private static void convertServiceInterfaces(TopologyTemplate toscaElement, Service service) {
295         Map<String, InterfaceDataDefinition> interfaces = toscaElement.getInterfaces();
296         Map<String, InterfaceDefinition> copy;
297         if (interfaces != null) {
298             copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue())));
299         } else {
300             copy = new HashMap<>();
301         }
302         service.setInterfaces(copy);
303     }
304
305     private static void convertAttributesToResource(NodeType nodeType, Resource resource) {
306         Map<String, AttributeDataDefinition> attributes = nodeType.getAttributes();
307         if (attributes != null) {
308             final Map<String, AttributeDefinition> attributeDefinitionMap = attributes.entrySet().stream()
309                 .collect(Collectors.toMap(Entry::getKey, o -> new AttributeDefinition(o.getValue())));
310             resource.setAttributes(new ArrayList<>(attributeDefinitionMap.values()));
311         }
312     }
313
314     private static void convertInterfaces(NodeType nodeType, Resource resource) {
315         Map<String, InterfaceDataDefinition> interfaceArtifacts = nodeType.getInterfaceArtifacts();
316         if (interfaceArtifacts != null) {
317             Map<String, InterfaceDefinition> interfaces = interfaceArtifacts.entrySet().stream()
318                 .collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue())));
319             resource.setInterfaces(interfaces);
320         }
321     }
322
323     /**
324      * Converts component instances of topology template to component instances of resource
325      *
326      * @param topologyTemplate
327      * @param component
328      */
329     public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) {
330         if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) {
331             setComponentInstancesAttributesToComponent(topologyTemplate, component);
332             setComponentInstancesPropertiesToComponent(topologyTemplate, component);
333             setComponentInstancesInputsToComponent(topologyTemplate, component);
334             setComponentInstancesOutputsToComponent(topologyTemplate, component);
335             setComponentInstancesToComponent(topologyTemplate, component);
336             setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component);
337             setComponentInstancesRequirementsToComponent(topologyTemplate, component);
338             setComponentInstancesArtifactsToComponent(topologyTemplate, component);
339             setComponentInstancesInterfacesToComponent(topologyTemplate, component);
340         }
341     }
342
343     private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) {
344         Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts();
345         Map<String, MapArtifactDataDefinition> instanceArtifacts = topologyTemplate.getInstanceArtifacts();
346         setComponentInstancesDeploymentArtifactsToComponent(instDeploymentArtifacts, component);
347         setComponentInstancesInformationalArtifactsToComponent(instanceArtifacts, component);
348     }
349
350     public static void setComponentInstancesInformationalArtifactsToComponent(Map<String, MapArtifactDataDefinition> instanceArtifacts,
351                                                                               Component component) {
352         List<ComponentInstance> instances = component.getComponentInstances();
353         if (instanceArtifacts != null && instances != null) {
354             instanceArtifacts.entrySet().forEach(e -> {
355                 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
356                 if (ci.isPresent()) {
357                     Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
358                     Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream()
359                         .collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
360                     ci.get().setArtifacts(deplArt);
361                 }
362             });
363         }
364     }
365
366     public static void setComponentInstancesDeploymentArtifactsToComponent(Map<String, MapArtifactDataDefinition> instDeploymentArtifacts,
367                                                                            Component component) {
368         List<ComponentInstance> instances = component.getComponentInstances();
369         if (instDeploymentArtifacts != null && instances != null) {
370             instDeploymentArtifacts.entrySet().forEach(e -> {
371                 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
372                 if (ci.isPresent()) {
373                     Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
374                     Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream()
375                         .collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
376                     ci.get().setDeploymentArtifacts(deplArt);
377                 }
378             });
379         }
380     }
381
382     public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) {
383         if (!CollectionUtils.isEmpty(component.getComponentInstances())) {
384             setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate);
385             setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate);
386             setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate);
387             setComponentInstancesToTopologyTemplate(component, topologyTemplate);
388             setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate);
389         }
390     }
391
392     public static void convertRelations(TopologyTemplate topologyTemplate, Component component) {
393         Map<String, RelationshipInstDataDefinition> relations = topologyTemplate.getRelations();
394         List<RequirementCapabilityRelDef> componentRelations;
395         if (relations != null && !relations.isEmpty()) {
396             componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList());
397         } else {
398             componentRelations = new ArrayList<>();
399         }
400         component.setComponentInstancesRelations(componentRelations);
401     }
402
403     public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) {
404         RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
405         requirementCapabilityRelDef.setFromNode(relation.getFromId());
406         requirementCapabilityRelDef.setToNode(relation.getToId());
407         requirementCapabilityRelDef.setOriginUI(BooleanUtils.isTrue(relation.isOriginUI()));
408         CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship();
409         RelationshipInfo relationshipPair = getRelationshipInfo(relation);
410         rel.setRelation(relationshipPair);
411         rel.setOperations(convertToOperations(relation.getInterfaces()));
412         requirementCapabilityRelDef.setRelationships(Arrays.asList(rel));
413         return requirementCapabilityRelDef;
414     }
415
416     private static List<OperationUi> convertToOperations(final ListDataDefinition<InterfaceDataDefinition> interfaces) {
417         if (interfaces == null || interfaces.isEmpty()) {
418             return Collections.emptyList();
419         }
420         final List<OperationUi> operationUiList = new ArrayList<>();
421         for (final InterfaceDataDefinition interfaceDataDefinition : interfaces.getListToscaDataDefinition()) {
422             if (MapUtils.isEmpty(interfaceDataDefinition.getOperations())) {
423                 continue;
424             }
425             for (final Entry<String, OperationDataDefinition> operationEntry : interfaceDataDefinition.getOperations().entrySet()) {
426                 final OperationUi operationUi = new OperationUi();
427                 operationUi.setOperationType(operationEntry.getKey());
428                 operationUi.setInterfaceType(interfaceDataDefinition.getType());
429                 final OperationDataDefinition operationDataDefinition = operationEntry.getValue();
430                 final ArtifactDataDefinition artifactDataDefinition = operationDataDefinition.getImplementation();
431                 if (artifactDataDefinition != null) {
432                     operationUi.setImplementation(artifactDataDefinition);
433                 }
434                 final ListDataDefinition<OperationInputDefinition> inputs = operationDataDefinition.getInputs();
435                 if (inputs != null && !inputs.isEmpty()) {
436                     final List<OperationInputDefinition> operationInputDefinitionList = inputs.getListToscaDataDefinition();
437                     operationInputDefinitionList.forEach(operationInputDefinition -> {
438                         final PropertyAssignmentUi propertyAssignmentUi = new PropertyAssignmentUi();
439                         propertyAssignmentUi.setName(operationInputDefinition.getLabel());
440                         propertyAssignmentUi.setType(operationInputDefinition.getType());
441                         propertyAssignmentUi.setValue(operationInputDefinition.getValue());
442                         operationUi.addToInputs(propertyAssignmentUi);
443                     });
444                 }
445                 operationUiList.add(operationUi);
446             }
447         }
448         return operationUiList;
449     }
450
451     /**
452      * @param relation
453      * @return
454      */
455     private static RelationshipInfo getRelationshipInfo(RelationshipInstDataDefinition relation) {
456         RelationshipInfo relationshipPair = new RelationshipInfo();
457         relationshipPair.setId(relation.getUniqueId());
458         relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
459         relationshipPair.setCapabilityUid(relation.getCapabilityId());
460         relationshipPair.setCapability(relation.getCapability());
461         relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
462         relationshipPair.setRequirementUid(relation.getRequirementId());
463         relationshipPair.setRequirement(relation.getRequirement());
464         RelationshipImpl relationship = new RelationshipImpl();
465         relationship.setType(relation.getType());
466         relationshipPair.setRelationships(relationship);
467         return relationshipPair;
468     }
469
470     public static List<RelationshipInstDataDefinition> convertRelationToToscaRelation(RequirementCapabilityRelDef relation) {
471         List<RelationshipInstDataDefinition> relationsList = new ArrayList<>();
472         List<CapabilityRequirementRelationship> relationship = relation.getRelationships();
473         relationship.forEach(p -> {
474             RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition();
475             requirementCapabilityRelDef.setFromId(relation.getFromNode());
476             requirementCapabilityRelDef.setToId(relation.getToNode());
477             requirementCapabilityRelDef.setUniqueId(p.getRelation().getId());
478             requirementCapabilityRelDef.setCapabilityOwnerId(p.getRelation().getCapabilityOwnerId());
479             requirementCapabilityRelDef.setCapabilityId(p.getRelation().getCapabilityUid());
480             requirementCapabilityRelDef.setRequirementOwnerId(p.getRelation().getRequirementOwnerId());
481             requirementCapabilityRelDef.setRequirementId(p.getRelation().getRequirementUid());
482             requirementCapabilityRelDef.setRequirement(p.getRelation().getRequirement());
483             requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType());
484             requirementCapabilityRelDef.setCapability(p.getRelation().getCapability());
485             requirementCapabilityRelDef.setOriginUI(relation.isOriginUI());
486             createRelationshipInterfaces(p.getOperations()).ifPresent(requirementCapabilityRelDef::setInterfaces);
487             relationsList.add(requirementCapabilityRelDef);
488         });
489         return relationsList;
490     }
491
492     private static Optional<ListDataDefinition<InterfaceDataDefinition>> createRelationshipInterfaces(final List<OperationUi> operationList) {
493         if (CollectionUtils.isEmpty(operationList)) {
494             return Optional.empty();
495         }
496         final ListDataDefinition<InterfaceDataDefinition> interfaceList = new ListDataDefinition<>();
497         final Map<String, List<OperationUi>> operationByInterfaceType = operationList.stream()
498             .collect(Collectors.groupingBy(OperationUi::getInterfaceType));
499         for (final Entry<String, List<OperationUi>> interfaceEntry : operationByInterfaceType.entrySet()) {
500             interfaceList.add(createInterface(interfaceEntry.getKey(), interfaceEntry.getValue()));
501         }
502         return Optional.of(interfaceList);
503     }
504
505     private static InterfaceDataDefinition createInterface(final String interfaceType, final List<OperationUi> operationList) {
506         final InterfaceDataDefinition interfaceDataDefinition = new InterfaceDataDefinition();
507         interfaceDataDefinition.setType(interfaceType);
508         if (CollectionUtils.isNotEmpty(operationList)) {
509             final Map<String, OperationDataDefinition> operationMap = operationList.stream()
510                 .collect(Collectors.toMap(OperationUi::getOperationType, ModelConverter::createOperation));
511             interfaceDataDefinition.setOperations(operationMap);
512         }
513         return interfaceDataDefinition;
514     }
515
516     private static OperationDataDefinition createOperation(final OperationUi operation) {
517         final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
518         operationDataDefinition.setName(operation.getOperationType());
519         operationDataDefinition.setUniqueId(UUID.randomUUID().toString());
520         final ArtifactDataDefinition artifactDataDefinition = (ArtifactDataDefinition) operation.getImplementation();
521         operationDataDefinition.setImplementation(artifactDataDefinition);
522         if (CollectionUtils.isNotEmpty(operation.getInputs())) {
523             final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
524             operation.getInputs().forEach(input -> {
525                 final OperationInputDefinition operationInputDefinition = new OperationInputDefinition();
526                 operationInputDefinition.setLabel(input.getName());
527                 operationInputDefinition.setType(input.getType());
528                 operationInputDefinition.setValue(input.getValue());
529                 inputs.add(operationInputDefinition);
530             });
531             operationDataDefinition.setInputs(inputs);
532         }
533         return operationDataDefinition;
534     }
535
536     private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) {
537         convertTopologyTemplateCapabilities(component, topologyTemplate);
538         if (componentInstancesCapabilitiesExist(component) || groupsCapabilitiesExist(component)) {
539             topologyTemplate.setCalculatedCapabilities(new HashMap<>());
540             topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
541         }
542         convertComponentInstancesCapabilities(component, topologyTemplate);
543         convertGroupsCapabilities(component, topologyTemplate);
544     }
545
546     private static void convertGroupsCapabilities(Component component, TopologyTemplate topologyTemplate) {
547         if (groupsCapabilitiesExist(component)) {
548             component.getGroups().stream().filter(g -> MapUtils.isNotEmpty(g.getCapabilities()))
549                 .forEach(g -> addCapabilities(topologyTemplate, g.getCapabilities(), g.getUniqueId()));
550         }
551     }
552
553     private static void convertTopologyTemplateCapabilities(Component component, ToscaElement toscaElement) {
554         Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
555         Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
556         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
557         if (MapUtils.isNotEmpty(capabilities)) {
558             capabilities.forEach((s, caps) -> {
559                 if (CollectionUtils.isNotEmpty(caps)) {
560                     List<CapabilityDataDefinition> capList = caps.stream()
561                         .filter(capabilityDefinition -> capabilityDefinition.getOwnerId().equals(component.getUniqueId()))
562                         .map(CapabilityDataDefinition::new).collect(Collectors.toList());
563                     populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
564                 }
565             });
566             toscaElement.setCapabilities(toscaCapMap);
567             toscaElement.setCapabilitiesProperties(toscaCapPropMap);
568         }
569     }
570
571     private static void populateCapabilityMap(Map<String, ListCapabilityDataDefinition> toscaCapMap,
572                                               Map<String, MapPropertiesDataDefinition> toscaCapPropMap, String s, List<CapabilityDefinition> caps,
573                                               List<CapabilityDataDefinition> capList) {
574         ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList);
575         toscaCapMap.put(s, listCapabilityDataDefinition);
576         for (CapabilityDefinition cap : caps) {
577             List<ComponentInstanceProperty> capPrps = cap.getProperties();
578             if (CollectionUtils.isNotEmpty(capPrps)) {
579                 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
580                 for (ComponentInstanceProperty cip : capPrps) {
581                     PropertyDataDefinition propertyDataDefinition = new PropertyDataDefinition(cip);
582                     propertyDataDefinition.setParentUniqueId(cap.getUniqueId());
583                     dataToCreate.put(cip.getName(), propertyDataDefinition);
584                 }
585                 toscaCapPropMap.put(s + CAP_PROP_DELIM + cap.getName(), dataToCreate);
586             }
587         }
588     }
589
590     private static void convertTopologyTemplateRequirements(Component component, ToscaElement toscaElement) {
591         Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
592         Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
593         if (MapUtils.isNotEmpty(requirements)) {
594             requirements.forEach((s, reqs) -> {
595                 if (CollectionUtils.isNotEmpty(reqs)) {
596                     List<RequirementDataDefinition> reqList = reqs.stream()
597                         .filter(requirementDefinition -> requirementDefinition.getOwnerId().equals(component.getUniqueId()))
598                         .map(RequirementDataDefinition::new).collect(Collectors.toList());
599                     ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
600                     toscaReqMap.put(s, listRequirementDataDefinition);
601                 }
602             });
603             toscaElement.setRequirements(toscaReqMap);
604         }
605     }
606
607     private static void convertComponentInstancesCapabilities(Component component, TopologyTemplate topologyTemplate) {
608         if (componentInstancesCapabilitiesExist(component)) {
609             component.getComponentInstances().stream().filter(i -> MapUtils.isNotEmpty(i.getCapabilities()))
610                 .forEach(i -> addCapabilities(topologyTemplate, i.getCapabilities(), i.getUniqueId()));
611         }
612     }
613
614     private static void addCapabilities(TopologyTemplate topologyTemplate, Map<String, List<CapabilityDefinition>> capabilities, String ownerId) {
615         if (MapUtils.isNotEmpty(capabilities)) {
616             if (topologyTemplate.getCalculatedCapabilities() == null) {
617                 topologyTemplate.setCalculatedCapabilities(new HashMap<>());
618             }
619             topologyTemplate.getCalculatedCapabilities().put(ownerId, convertToMapListCapabiltyDataDefinition(capabilities));
620             if (topologyTemplate.getCalculatedCapabilitiesProperties() == null) {
621                 topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
622             }
623             topologyTemplate.getCalculatedCapabilitiesProperties().put(ownerId, convertToMapOfMapCapabiltyProperties(capabilities, ownerId));
624         }
625     }
626
627     private static boolean componentInstancesCapabilitiesExist(Component component) {
628         return component.getCapabilities() != null && component.getComponentInstances() != null && component.getComponentInstances().stream()
629             .anyMatch(ci -> MapUtils.isNotEmpty(ci.getCapabilities()));
630     }
631
632     private static boolean groupsCapabilitiesExist(Component component) {
633         return component.getCapabilities() != null && component.getGroups() != null && component.getGroups().stream()
634             .anyMatch(g -> MapUtils.isNotEmpty(g.getCapabilities()));
635     }
636
637     public static MapCapabilityProperty convertToMapOfMapCapabilityProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId,
638                                                                               boolean isAtomicType) {
639         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
640         if (MapUtils.isNotEmpty(capabilities)) {
641             capabilities.forEach((s, caps) -> addCapsProperties(ownerId, isAtomicType, toscaCapPropMap, caps));
642         }
643         return new MapCapabilityProperty(toscaCapPropMap);
644     }
645
646     private static void addCapsProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap,
647                                           List<CapabilityDefinition> caps) {
648         if (CollectionUtils.isNotEmpty(caps)) {
649             caps.forEach(cap -> addCapProperties(ownerId, isAtomicType, toscaCapPropMap, cap));
650         }
651     }
652
653     private static void addCapProperties(String ownerId, boolean isAtomicType, Map<String, MapPropertiesDataDefinition> toscaCapPropMap,
654                                          CapabilityDefinition cap) {
655         if (CollectionUtils.isNotEmpty(cap.getProperties())) {
656             MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition(
657                 cap.getProperties().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, p -> p)));
658             toscaCapPropMap.put(buildCapabilityPropertyKey(isAtomicType, cap.getType(), cap.getName(), ownerId, cap),
659                 new MapPropertiesDataDefinition(dataToCreate));
660         }
661     }
662
663     public static String buildCapabilityPropertyKey(boolean isAtomicType, String capabilityType, String capabilityName,
664                                                     String componentInstanceUniqueId, CapabilityDefinition cap) {
665         StringBuilder sb = new StringBuilder(componentInstanceUniqueId);
666         sb.append(CAP_PROP_DELIM).append(cap.getOwnerId()).append(CAP_PROP_DELIM);
667         if (!isAtomicType && !componentInstanceUniqueId.equals(cap.getOwnerId())) {
668             sb.append(cap.getOwnerId()).append(CAP_PROP_DELIM);
669         }
670         return sb.append(capabilityType).append(CAP_PROP_DELIM).append(capabilityName).toString();
671     }
672
673     public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities,
674                                                                              String ownerId) {
675         return convertToMapOfMapCapabiltyProperties(instCapabilities, ownerId, false);
676     }
677
678     public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId,
679                                                                              boolean fromCsar) {
680         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
681         if (MapUtils.isNotEmpty(capabilities)) {
682             capabilities.forEach((s, caps) -> {
683                 if (caps != null && !caps.isEmpty()) {
684                     MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
685                     for (CapabilityDefinition cap : caps) {
686                         List<ComponentInstanceProperty> capPrps = cap.getProperties();
687                         if (capPrps != null) {
688                             for (ComponentInstanceProperty cip : capPrps) {
689                                 dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
690                             }
691                             // format key of capability properties :
692
693                             // VF instance in service : instanceId#ownerId#type#capName
694
695                             // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId
696                             StringBuilder sb = new StringBuilder(ownerId);
697                             sb.append(CAP_PROP_DELIM);
698                             if (fromCsar) {
699                                 sb.append(ownerId);
700                             } else {
701                                 sb.append(cap.getOwnerId());
702                             }
703                             sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
704                             toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate));
705                         }
706                     }
707                 }
708             });
709         }
710         return new MapCapabilityProperty(toscaCapPropMap);
711     }
712
713     private static MapListCapabilityDataDefinition convertToMapListCapabiltyDataDefinition(Map<String, List<CapabilityDefinition>> instCapabilities) {
714         Map<String, ListCapabilityDataDefinition> mapToscaDataDefinition = new HashMap<>();
715         for (Entry<String, List<CapabilityDefinition>> instCapability : instCapabilities.entrySet()) {
716             mapToscaDataDefinition.put(instCapability.getKey(),
717                 new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList())));
718         }
719         return new MapListCapabilityDataDefinition(mapToscaDataDefinition);
720     }
721
722     private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) {
723         convertTopologyTemplateRequirements(component, topologyTemplate);
724         if (component.getRequirements() != null && component.getComponentInstances() != null) {
725             topologyTemplate.setCalculatedRequirements(new HashMap<>());
726             for (ComponentInstance instance : component.getComponentInstances()) {
727                 Map<String, List<RequirementDefinition>> instRequirements = instance.getRequirements();
728                 if (MapUtils.isNotEmpty(instRequirements)) {
729                     if (topologyTemplate.getCalculatedRequirements() == null) {
730                         topologyTemplate.setCalculatedRequirements(new HashMap<>());
731                     }
732                     topologyTemplate.getCalculatedRequirements()
733                         .put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements));
734                 }
735             }
736         }
737     }
738
739     private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(
740         Map<String, List<RequirementDefinition>> instRequirements) {
741         Map<String, ListRequirementDataDefinition> mapToscaDataDefinition = new HashMap<>();
742         for (Entry<String, List<RequirementDefinition>> instRequirement : instRequirements.entrySet()) {
743             mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(
744                 instRequirement.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList())));
745         }
746         return new MapListRequirementDataDefinition(mapToscaDataDefinition);
747     }
748
749     @SuppressWarnings("unchecked")
750     private static void convertComponentFields(Component component, ToscaElement toscaElement) {
751         component.setName(toscaElement.getName());
752         component.setAllVersions(toscaElement.getAllVersions());
753         component.setCategories(toscaElement.getCategories());
754         component.setComponentType(toscaElement.getComponentType());
755         component.setCreationDate(toscaElement.getCreationDate());
756         component.setCreatorUserId(toscaElement.getCreatorUserId());
757         component.setCreatorFullName(toscaElement.getCreatorFullName());
758         component.setLastUpdateDate(toscaElement.getLastUpdateDate());
759         component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName());
760         component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId());
761         component.setNormalizedName(toscaElement.getNormalizedName());
762         component.setLifecycleState(toscaElement.getLifecycleState());
763         component.setVersion(toscaElement.getVersion());
764         component.setHighestVersion(toscaElement.isHighestVersion());
765         component.setUniqueId(toscaElement.getUniqueId());
766         component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME));
767         component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType());
768         component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion());
769         if(toscaElement.getModel() != null) {
770             component.setModel(toscaElement.getModel());
771         }
772         Map<String, PropertyDataDefinition> properties = toscaElement.getProperties();
773         if (MapUtils.isNotEmpty(properties)) {
774             List<PropertyDefinition> propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList());
775             component.setProperties(propertiesMap);
776         }
777         //archive
778         component.setArchived(toscaElement.isArchived() == null ? false : toscaElement.isArchived());
779         component.setArchiveTime(toscaElement.getArchiveTime());
780         component.setVspArchived(toscaElement.isVspArchived() == null ? false : toscaElement.isVspArchived());
781         if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
782             Resource resource = (Resource) component;
783             resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
784             resource.setToscaResourceName((String) toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
785             resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME));
786             resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE));
787             // field isn't mandatory , but shouldn't be null(should be an empty string instead)
788             if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null) {
789                 resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER));
790             } else {
791                 resource.setResourceVendorModelNumber("");
792             }
793             Boolean isNormative = toscaElement.getMetadataValue(JsonPresentationFields.NORMATIVE) == null ? false : (Boolean) toscaElement.getMetadataValue(JsonPresentationFields.NORMATIVE);
794             resource.getComponentMetadataDefinition().getMetadataDataDefinition().setNormative(isNormative);
795         } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
796             Service service = (Service) component;
797             if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null) {
798                 service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE));
799             } else {
800                 service.setServiceType("");
801             }
802             if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null) {
803                 service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE));
804             } else {
805                 service.setServiceRole("");
806             }
807             if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_FUNCTION)) != null) {
808                 service.setServiceFunction((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_FUNCTION));
809             } else {
810                 service.setServiceFunction("");
811             }
812         }
813         component.setConformanceLevel((String) toscaElement.getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL));
814         component.setIcon((String) toscaElement.getMetadataValue(JsonPresentationFields.ICON));
815         component.setDescription((String) toscaElement.getMetadataValue(JsonPresentationFields.DESCRIPTION));
816         component.setTags((List<String>) toscaElement.getMetadataValue(JsonPresentationFields.TAGS));
817         component.setInvariantUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID));
818         component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID));
819         component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID));
820         component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED));
821         component.setModel((String) toscaElement.getMetadataValue(JsonPresentationFields.MODEL));
822         component.setToscaType(toscaElement.getToscaType().getValue());
823         final List<MetadataKeyDataDefinition> metadataKeys = getCategorySpecificMetadataKeys(toscaElement);
824         if (CollectionUtils.isNotEmpty(metadataKeys)) {
825             final Map<String, String> categorySpecificMetadata = new HashMap<>();
826             for (final MetadataKeyDataDefinition metadataKey : metadataKeys) {
827                 if (toscaElement.getMetadata().get(metadataKey.getName()) != null) {
828                     categorySpecificMetadata.put(metadataKey.getName(), (String) toscaElement.getMetadata().get(metadataKey.getName()));
829                 } else if (metadataKey.getDefaultValue() != null && metadataKey.isMandatory()) {
830                     categorySpecificMetadata.put(metadataKey.getName(), metadataKey.getDefaultValue());
831                 }
832             }
833             component.setCategorySpecificMetadata(categorySpecificMetadata);
834         }
835     }
836     
837     private static List<MetadataKeyDataDefinition> getCategorySpecificMetadataKeys(final ToscaElement toscaElement) {
838         final List<MetadataKeyDataDefinition> metadataKeys = new ArrayList<>();
839         final Optional<CategoryDefinition> category = getCategory(toscaElement);
840         if (category.isPresent()) {
841             if (CollectionUtils.isNotEmpty(category.get().getMetadataKeys())) {
842                 metadataKeys.addAll(category.get().getMetadataKeys());
843             }
844             final Optional<SubCategoryDefinition> subCategory = getSubCategory(category.get());
845             if (subCategory.isPresent() && CollectionUtils.isNotEmpty(subCategory.get().getMetadataKeys())) {
846                 metadataKeys.addAll(subCategory.get().getMetadataKeys());
847             }
848         }
849         return metadataKeys;
850     }
851
852     private static Optional<CategoryDefinition> getCategory(ToscaElement toscaElement) {
853         return CollectionUtils.isEmpty(toscaElement.getCategories()) ? Optional.empty() : Optional.of(toscaElement.getCategories().get(0));
854     }
855
856     private static Optional<SubCategoryDefinition> getSubCategory(CategoryDefinition category) {
857         return CollectionUtils.isEmpty(category.getSubcategories()) ? Optional.empty() : Optional.of(category.getSubcategories().get(0));
858     }
859
860     private static NodeType convertToNodeType(Component component) {
861         Resource resource = (Resource) component;
862         NodeType nodeType = new NodeType();
863         nodeType.setDerivedFrom(resource.getDerivedFrom());
864         nodeType.setDerivedList(resource.getDerivedList());
865         nodeType.setResourceType(resource.getResourceType());
866         final String toscaVersion = resource.getToscaVersion();
867         if (toscaVersion != null) {
868             nodeType.setToscaVersion(toscaVersion);
869         }
870         final List<DataTypeDefinition> dataTypes = resource.getDataTypes();
871         if (CollectionUtils.isNotEmpty(dataTypes)) {
872             nodeType
873                 .setDataTypes(dataTypes.stream().collect(Collectors.toMap(DataTypeDefinition::getName, dataTypeDefinition -> dataTypeDefinition)));
874         }
875         convertCommonToscaData(component, nodeType);
876         convertAdditionalInformation(component, nodeType);
877         convertArtifacts(resource, nodeType);
878         convertCapabilities(resource, nodeType);
879         convertRequirements(resource, nodeType);
880         convertAttributesToNodeType(resource, nodeType);
881         convertProperties(resource, nodeType);
882         convertInterfaces(resource, nodeType);
883         return nodeType;
884     }
885
886     private static void convertProperties(Resource resource, NodeType nodeType) {
887         List<PropertyDefinition> properties = resource.getProperties();
888         if (properties != null && !properties.isEmpty()) {
889             Map<String, PropertyDataDefinition> propertiesMap = properties.stream()
890                 .collect(Collectors.toMap(PropertyDefinition::getName, PropertyDataDefinition::new));
891             nodeType.setProperties(propertiesMap);
892         }
893     }
894
895     private static void convertInterfaces(Resource resource, NodeType nodeType) {
896         Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
897         if (interfaces != null) {
898             Map<String, InterfaceDataDefinition> interfaceArtifacts = interfaces.entrySet().stream()
899                 .collect(Collectors.toMap(Map.Entry::getKey, x -> new InterfaceDataDefinition(x.getValue())));
900             nodeType.setInterfaceArtifacts(interfaceArtifacts);
901         }
902     }
903
904     private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) {
905         List<AdditionalInformationDefinition> additionalInformation = component.getAdditionalInformation();
906         if (additionalInformation != null) {
907             Map<String, AdditionalInfoParameterDataDefinition> addInfo = additionalInformation.stream()
908                 .collect(Collectors.toMap(AdditionalInformationDefinition::getUniqueId, AdditionalInfoParameterDataDefinition::new));
909             toscaElement.setAdditionalInformation(addInfo);
910         }
911     }
912
913     private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) {
914         Map<String, AdditionalInfoParameterDataDefinition> additionalInformation = toscaElement.getAdditionalInformation();
915         if (additionalInformation != null) {
916             List<AdditionalInformationDefinition> addInfo = additionalInformation.values().stream().map(AdditionalInformationDefinition::new)
917                 .collect(Collectors.toList());
918             resource.setAdditionalInformation(addInfo);
919         }
920     }
921
922     private static void convertArtifacts(ToscaElement toscaElement, Component component) {
923         Map<String, ArtifactDataDefinition> artifacts = toscaElement.getArtifacts();
924         Map<String, ArtifactDefinition> copy;
925         if (artifacts != null) {
926             copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
927         } else {
928             copy = new HashMap<>();
929         }
930         component.setArtifacts(copy);
931         Map<String, ArtifactDataDefinition> toscaArtifacts = toscaElement.getToscaArtifacts();
932         if (toscaArtifacts != null) {
933             copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
934         } else {
935             copy = new HashMap<>();
936         }
937         component.setToscaArtifacts(copy);
938         Map<String, ArtifactDataDefinition> deploymentArtifacts = toscaElement.getDeploymentArtifacts();
939         if (deploymentArtifacts != null) {
940             copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
941         } else {
942             copy = new HashMap<>();
943         }
944         component.setDeploymentArtifacts(copy);
945     }
946
947     private static void convertNodeFiltersComponents(final TopologyTemplate topologyTemplate, final Component component) {
948         final Map<String, CINodeFilterDataDefinition> filters = topologyTemplate.getNodeFilterComponents();
949         final Map<String, CINodeFilterDataDefinition> copy;
950         if (MapUtils.isNotEmpty(filters)) {
951             copy = filters.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new CINodeFilterDataDefinition(e.getValue())));
952         } else {
953             copy = new HashMap<>();
954         }
955         component.setNodeFilterComponents(copy);
956     }
957
958     private static void convertSubstitutionFiltersComponents(final TopologyTemplate topologyTemplate, final Component component) {
959         final SubstitutionFilterDataDefinition filters = topologyTemplate.getSubstitutionFilters();
960         if (filters == null){
961             component.setSubstitutionFilter(null);
962             return;
963         }
964         component.setSubstitutionFilter(new SubstitutionFilterDataDefinition(filters));
965     }
966
967     private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) {
968         Map<String, ArtifactDataDefinition> serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts();
969         Map<String, ArtifactDefinition> copy;
970         if (serviceApiArtifacts != null) {
971             copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
972         } else {
973             copy = new HashMap<>();
974         }
975         service.setServiceApiArtifacts(copy);
976     }
977
978     private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) {
979         Map<String, ForwardingPathDataDefinition> servicePaths = topologyTemplate.getForwardingPaths();
980         Map<String, ForwardingPathDataDefinition> copy;
981         if (servicePaths != null) {
982             copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
983         } else {
984             copy = new HashMap<>();
985         }
986         service.setForwardingPaths(copy);
987     }
988
989     private static void convertArtifacts(Component component, ToscaElement toscaElement) {
990         Map<String, ArtifactDefinition> artifacts = component.getArtifacts();
991         if (artifacts != null) {
992             Map<String, ArtifactDataDefinition> copy = artifacts.entrySet().stream()
993                 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
994             toscaElement.setArtifacts(copy);
995         }
996         Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
997         if (toscaArtifacts != null) {
998             Map<String, ArtifactDataDefinition> copy = toscaArtifacts.entrySet().stream()
999                 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1000             toscaElement.setToscaArtifacts(copy);
1001         }
1002         Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
1003         if (deploymentArtifacts != null) {
1004             Map<String, ArtifactDataDefinition> copy = deploymentArtifacts.entrySet().stream()
1005                 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1006             toscaElement.setDeploymentArtifacts(copy);
1007         }
1008     }
1009
1010     private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) {
1011         Map<String, ArtifactDefinition> serviceApiArtifacts = service.getServiceApiArtifacts();
1012         if (serviceApiArtifacts != null) {
1013             Map<String, ArtifactDataDefinition> copy = serviceApiArtifacts.entrySet().stream()
1014                 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1015             topologyTemplate.setServiceApiArtifacts(copy);
1016         }
1017     }
1018
1019     private static void convertCapabilities(Component component, NodeType toscaElement) {
1020         Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
1021         Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
1022         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
1023         if (capabilities != null && !capabilities.isEmpty()) {
1024             capabilities.forEach((s, caps) -> {
1025                 if (caps != null && !caps.isEmpty()) {
1026                     List<CapabilityDataDefinition> capList = caps.stream().map(CapabilityDataDefinition::new).collect(Collectors.toList());
1027                     populateCapabilityMap(toscaCapMap, toscaCapPropMap, s, caps, capList);
1028                 }
1029             });
1030             toscaElement.setCapabilities(toscaCapMap);
1031             toscaElement.setCapabilitiesProperties(toscaCapPropMap);
1032         }
1033     }
1034
1035     private static void convertAttributesToNodeType(Resource component, NodeType nodeType) {
1036         List<AttributeDefinition> attributes = component.getAttributes();
1037         if (CollectionUtils.isNotEmpty(attributes)) {
1038             Map<String, AttributeDataDefinition> attrsByName = attributes.stream()
1039                 .collect(Collectors.toMap(AttributeDefinition::getName, Function.identity()));
1040             nodeType.setAttributes(attrsByName);
1041         }
1042     }
1043
1044     private static void convertRequirements(Resource component, NodeType nodeType) {
1045         Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
1046         Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
1047         if (requirements != null && !requirements.isEmpty()) {
1048             requirements.forEach((s, reqs) -> {
1049                 if (reqs != null && !reqs.isEmpty()) {
1050                     List<RequirementDataDefinition> reqList = reqs.stream().map(RequirementDataDefinition::new).collect(Collectors.toList());
1051                     ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
1052                     toscaReqMap.put(s, listRequirementDataDefinition);
1053                 }
1054             });
1055             nodeType.setRequirements(toscaReqMap);
1056         }
1057     }
1058
1059     private static void convertCapabilities(NodeType toscaElement, Component component) {
1060         Map<String, ListCapabilityDataDefinition> toscaCapabilities = toscaElement.getCapabilities();
1061         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = toscaElement.getCapabilitiesProperties();
1062         Map<String, List<CapabilityDefinition>> capabilitiesMapFromMapObject = getCapabilitiesMapFromMapObject(toscaCapabilities, toscaCapPropMap);
1063         if (capabilitiesMapFromMapObject != null) {
1064             component.setCapabilities(capabilitiesMapFromMapObject);
1065         }
1066     }
1067
1068     public static Map<String, List<CapabilityDefinition>> getCapabilitiesMapFromMapObject(Map<String, ListCapabilityDataDefinition> toscaCapabilities,
1069                                                                                           Map<String, MapPropertiesDataDefinition> toscaCapPropMap) {
1070         Map<String, List<CapabilityDefinition>> compCap = new HashMap<>();
1071         if (toscaCapabilities == null || toscaCapabilities.isEmpty()) {
1072             return null;
1073         }
1074         toscaCapabilities.forEach((s, cap) -> {
1075             if (cap != null) {
1076                 List<CapabilityDataDefinition> capDataList = cap.getListToscaDataDefinition();
1077                 if (capDataList != null && !capDataList.isEmpty()) {
1078                     List<CapabilityDefinition> capList = capDataList.stream().map(CapabilityDefinition::new).collect(Collectors.toList());
1079                     compCap.put(s, capList);
1080                 }
1081             }
1082         });
1083         if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) {
1084             toscaCapPropMap.forEach((s, capProp) -> {
1085                 String[] result = s.split(CAP_PROP_DELIM);
1086                 if (capProp != null) {
1087                     Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
1088                     if (capMap != null && !capMap.isEmpty()) {
1089                         List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new)
1090                             .collect(Collectors.toList());
1091                         List<CapabilityDefinition> cap = compCap.get(result[0]);
1092                         Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
1093                         op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
1094                     }
1095                 }
1096             });
1097         }
1098         return compCap;
1099     }
1100
1101     private static void convertGroups(TopologyTemplate toscaElement, Component component) {
1102         Map<String, GroupDataDefinition> toscaGroups = toscaElement.getGroups();
1103         List<GroupDefinition> groupDefinitions = null;
1104         if (MapUtils.isNotEmpty(toscaGroups)) {
1105             groupDefinitions = toscaGroups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
1106         }
1107         component.setGroups(groupDefinitions);
1108     }
1109
1110     private static void convertPolicies(TopologyTemplate toscaElement, Component component) {
1111         Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies();
1112         Map<String, PolicyDefinition> policyDefinitions = null;
1113         if (MapUtils.isNotEmpty(policies)) {
1114             policyDefinitions = policies.values().stream().map(PolicyDefinition::new)
1115                 .collect(Collectors.toMap(PolicyDefinition::getUniqueId, Function.identity()));
1116         }
1117         component.setPolicies(policyDefinitions);
1118     }
1119
1120     private static void convertGroups(Component component, TopologyTemplate toscaElement) {
1121         List<GroupDefinition> groupDefinitions = component.getGroups();
1122         Map<String, GroupDataDefinition> groups = new HashMap<>();
1123         if (groupDefinitions != null && groups.isEmpty()) {
1124             groups = groupDefinitions.stream().collect(Collectors.toMap(GroupDefinition::getInvariantName, GroupDefinition::new));
1125         }
1126         toscaElement.setGroups(groups);
1127     }
1128
1129     private static void convertPolicies(Component component, TopologyTemplate toscaElement) {
1130         Map<String, PolicyDefinition> policyDefinitions = component.getPolicies();
1131         Map<String, PolicyDataDefinition> policies = new HashMap<>();
1132         if (MapUtils.isNotEmpty(policyDefinitions)) {
1133             policies = policyDefinitions.values().stream().collect((Collectors.toMap(PolicyDefinition::getUniqueId, PolicyDataDefinition::new)));
1134         }
1135         toscaElement.setPolicies(policies);
1136     }
1137
1138     private static void convertRequirements(NodeType toscaElement, Component component) {
1139         Map<String, ListRequirementDataDefinition> toscaRequirements = toscaElement.getRequirements();
1140         Map<String, List<RequirementDefinition>> compReqs = new HashMap<>();
1141         if (toscaRequirements == null || toscaRequirements.isEmpty()) {
1142             return;
1143         }
1144         toscaRequirements.forEach((s, req) -> {
1145             if (req != null) {
1146                 List<RequirementDataDefinition> reqDataList = req.getListToscaDataDefinition();
1147                 if (reqDataList != null && !reqDataList.isEmpty()) {
1148                     List<RequirementDefinition> reqList = reqDataList.stream().map(RequirementDefinition::new).collect(Collectors.toList());
1149                     compReqs.put(s, reqList);
1150                 }
1151             }
1152         });
1153         component.setRequirements(compReqs);
1154     }
1155
1156     private static TopologyTemplate convertToTopologyTemplate(Component component) {
1157         TopologyTemplate topologyTemplate;
1158         ComponentTypeEnum componentType = component.getComponentType();
1159         topologyTemplate = new TopologyTemplate();
1160         if (componentType == ComponentTypeEnum.RESOURCE) {
1161             Resource resource = (Resource) component;
1162             topologyTemplate.setResourceType(resource.getResourceType());
1163             topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
1164             topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
1165             topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION_ID, resource.getCsarVersionId());
1166             topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
1167             convertTopologyTemplateInterfaces(resource, topologyTemplate);
1168         }
1169         if (componentType == ComponentTypeEnum.SERVICE) {
1170             convertServiceSpecificEntities((Service) component, topologyTemplate);
1171         }
1172         convertCommonToscaData(component, topologyTemplate);
1173         convertArtifacts(component, topologyTemplate);
1174         convertAdditionalInformation(component, topologyTemplate);
1175         convertComponentInstances(component, topologyTemplate);
1176         convertInputs(component, topologyTemplate);
1177         convertProperties(component, topologyTemplate);
1178         convertAttributesToTopologyTemplate(component, topologyTemplate);
1179         convertCapabilities(component, topologyTemplate);
1180         convertGroups(component, topologyTemplate);
1181         convertPolicies(component, topologyTemplate);
1182         convertRequirements(component, topologyTemplate);
1183         convertRelationsToComposition(component, topologyTemplate);
1184         return topologyTemplate;
1185     }
1186
1187     private static void convertTopologyTemplateInterfaces(Resource resource, TopologyTemplate topologyTemplate) {
1188         Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
1189         if (interfaces != null && !interfaces.isEmpty()) {
1190             Map<String, InterfaceDataDefinition> copy = interfaces.entrySet().stream()
1191                 .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue())));
1192             topologyTemplate.setInterfaces(copy);
1193         }
1194     }
1195
1196     private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) {
1197         convertServiceMetaData(service, topologyTemplate);
1198         convertServiceApiArtifacts(service, topologyTemplate);
1199         convertServicePaths(service, topologyTemplate);
1200         convertServiceInterfaces(topologyTemplate, service);
1201     }
1202
1203     private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) {
1204         Map<String, ForwardingPathDataDefinition> servicePaths = service.getForwardingPaths();
1205         if (servicePaths != null && !servicePaths.isEmpty()) {
1206             Map<String, ForwardingPathDataDefinition> copy = servicePaths.entrySet().stream()
1207                 .collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
1208             topologyTemplate.setForwardingPaths(copy);
1209         }
1210     }
1211
1212     private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
1213         if (service.getDistributionStatus() != null) {
1214             topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS, service.getDistributionStatus().name());
1215         }
1216         topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
1217         topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, service.isEcompGeneratedNaming());
1218         topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
1219         topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext());
1220         topologyTemplate.setMetadataValue(JsonPresentationFields.INSTANTIATION_TYPE, service.getInstantiationType());
1221     }
1222
1223     private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) {
1224         List<RequirementCapabilityRelDef> componentInstancesRelations = component.getComponentInstancesRelations();
1225         if (componentInstancesRelations != null) {
1226             Map<String, CompositionDataDefinition> compositions = topologyTemplate.getCompositions();
1227             if (compositions == null) {
1228                 compositions = new HashMap<>();
1229             }
1230             CompositionDataDefinition compositionDataDefinition = compositions.get(JsonConstantKeysEnum.COMPOSITION.getValue());
1231             if (compositionDataDefinition == null) {
1232                 compositionDataDefinition = new CompositionDataDefinition();
1233                 compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition);
1234             }
1235             Map<String, RelationshipInstDataDefinition> relations = componentInstancesRelations.stream()
1236                 .flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null)
1237                 .collect(Collectors.toMap(RelationshipInstDataDefinition::getUniqueId, Function.identity()));
1238             compositionDataDefinition.setRelations(relations);
1239         }
1240     }
1241
1242     private static void convertInputs(Component component, TopologyTemplate topologyTemplate) {
1243         List<InputDefinition> inputsList = component.getInputs();
1244         if (inputsList != null && !inputsList.isEmpty()) {
1245             Map<String, PropertyDataDefinition> inputsMap = inputsList.stream().map(PropertyDataDefinition::new)
1246                 .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
1247             topologyTemplate.setInputs(inputsMap);
1248         }
1249     }
1250
1251     private static void convertInputs(TopologyTemplate topologyTemplate, Component component) {
1252         Map<String, PropertyDataDefinition> inputsMap = topologyTemplate.getInputs();
1253         if (inputsMap != null && !inputsMap.isEmpty()) {
1254             List<InputDefinition> inputsList = inputsMap.values().stream().map(InputDefinition::new).collect(Collectors.toList());
1255             component.setInputs(inputsList);
1256         }
1257     }
1258
1259     private static void convertOutputs(final TopologyTemplate topologyTemplate, final Component component) {
1260         final Map<String, AttributeDataDefinition> outputsMap = topologyTemplate.getOutputs();
1261         if (MapUtils.isEmpty(outputsMap)) {
1262             return;
1263         }
1264         final List<OutputDefinition> outputList = outputsMap.values().stream().map(OutputDefinition::new).collect(Collectors.toList());
1265         component.setOutputs(outputList);
1266     }
1267
1268     private static void convertProperties(Component component, TopologyTemplate topologyTemplate) {
1269         List<PropertyDefinition> propertiesList = component.getProperties();
1270         if (propertiesList != null && !propertiesList.isEmpty()) {
1271             Map<String, PropertyDataDefinition> propertiesMap = propertiesList.stream().map(i -> new PropertyDataDefinition(i))
1272                 .collect(Collectors.toMap(i -> i.getName(), i -> i));
1273             topologyTemplate.setProperties(propertiesMap);
1274         }
1275     }
1276
1277     private static void convertAttributesToTopologyTemplate(final Component component, final TopologyTemplate topologyTemplate) {
1278         final List<AttributeDefinition> attributes = component.getAttributes();
1279         if (CollectionUtils.isNotEmpty(attributes)) {
1280             final Map<String, AttributeDataDefinition> attributeDataDefinitionMap = attributes.stream().map(AttributeDataDefinition::new)
1281                 .collect(Collectors.toMap(AttributeDataDefinition::getName, i -> i));
1282             topologyTemplate.setAttributes(attributeDataDefinitionMap);
1283         }
1284     }
1285
1286     private static void convertProperties(TopologyTemplate topologyTemplate, Component component) {
1287         Map<String, PropertyDataDefinition> propertiesMap = topologyTemplate.getProperties();
1288         if (propertiesMap != null && !propertiesMap.isEmpty()) {
1289             Map<String, PropertyDefinition> copy = propertiesMap.entrySet().stream()
1290                 .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new PropertyDefinition(entry.getValue())));
1291             component.setProperties(new ArrayList<>(copy.values()));
1292         }
1293     }
1294
1295     private static void convertAttributesToComponent(final TopologyTemplate topologyTemplate, final Component component) {
1296         final Map<String, AttributeDataDefinition> attributes = topologyTemplate.getAttributes();
1297         if (MapUtils.isNotEmpty(attributes)) {
1298             Map<String, AttributeDefinition> copy = attributes.entrySet().stream()
1299                 .collect(Collectors.toMap(entry -> entry.getKey(), entry -> new AttributeDefinition(entry.getValue())));
1300             component.setAttributes(new ArrayList<>(copy.values()));
1301         }
1302     }
1303
1304     private static void convertDataTypes(final ToscaElement toscaElement, final Component component) {
1305         final Map<String, DataTypeDataDefinition> dataTypeDataMap = toscaElement.getDataTypes();
1306         if (MapUtils.isNotEmpty(dataTypeDataMap)) {
1307             final List<DataTypeDefinition> dataTypeDefinitionList = dataTypeDataMap.values().stream().map(dataTypeDataDefinition -> {
1308                 final DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(dataTypeDataDefinition);
1309                 if (CollectionUtils.isNotEmpty(dataTypeDataDefinition.getPropertiesData())) {
1310                     log.debug("#convertDataTypes - propertiesData is not null. {}",
1311                         ReflectionToStringBuilder.toString(dataTypeDataDefinition.getPropertiesData()));
1312                     dataTypeDefinition
1313                         .setProperties(dataTypeDataDefinition.getPropertiesData().stream().map(PropertyDefinition::new).collect(Collectors.toList()));
1314                 } else {
1315                     log.debug("#convertDataTypes - propertiesData is null. ignore.");
1316                 }
1317                 return dataTypeDefinition;
1318             }).collect(Collectors.toList());
1319             component.setDataTypes(dataTypeDefinitionList);
1320         }
1321     }
1322
1323     private static void convertCommonToscaData(Component component, ToscaElement toscaElement) {
1324         toscaElement.setUUID(component.getUUID());
1325         toscaElement.setUniqueId(component.getUniqueId());
1326         toscaElement.setSystemName(component.getSystemName());
1327         toscaElement.setLifecycleState(component.getLifecycleState());
1328         toscaElement.setComponentType(component.getComponentType());
1329         toscaElement.setNormalizedName(component.getNormalizedName());
1330         toscaElement.setMetadataValue(JsonPresentationFields.NAME, component.getName());
1331         toscaElement.setCategories(component.getCategories());
1332         toscaElement.setCreatorUserId(component.getCreatorUserId());
1333         toscaElement.setCreationDate(component.getCreationDate());
1334         toscaElement.setCreatorFullName(component.getCreatorFullName());
1335         toscaElement.setHighestVersion(component.isHighestVersion());
1336         toscaElement.setLastUpdateDate(component.getLastUpdateDate());
1337         toscaElement.setLastUpdaterFullName(component.getLastUpdaterFullName());
1338         toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId());
1339         toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType());
1340         toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion());
1341         //Archive
1342         toscaElement.setArchived(component.isArchived() == null ? false : component.isArchived());
1343         toscaElement.setArchiveTime(component.getArchiveTime() == null ? 0L : component.getArchiveTime());
1344         toscaElement.setVspArchived(component.isVspArchived() == null ? false : component.isVspArchived());
1345         toscaElement.setLifecycleState(component.getLifecycleState());
1346         toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion());
1347         if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
1348             toscaElement.setMetadataValue(JsonPresentationFields.IS_ABSTRACT, ((Resource) component).isAbstract());
1349             toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName());
1350             toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName());
1351             toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease());
1352             toscaElement.setMetadataValue(JsonPresentationFields.MODEL, component.getModel());
1353             // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1354             if (((Resource) component).getResourceVendorModelNumber() != null) {
1355                 toscaElement
1356                     .setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber());
1357             } else {
1358                 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, "");
1359             }
1360             toscaElement.setMetadataValue(JsonPresentationFields.NORMATIVE, ((Resource) component).getComponentMetadataDefinition().getMetadataDataDefinition().isNormative());
1361         } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
1362             // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1363             if (((Service) component).getServiceType() != null) {
1364                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType());
1365             } else {
1366                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, "");
1367             }
1368             if (((Service) component).getServiceRole() != null) {
1369                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole());
1370             } else {
1371                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, "");
1372             }
1373             if (((Service) component).getServiceFunction() != null) {
1374                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_FUNCTION, ((Service) component).getServiceFunction());
1375             } else {
1376                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_FUNCTION, "");
1377             }
1378         }
1379         toscaElement.setMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL, component.getConformanceLevel());
1380         toscaElement.setMetadataValue(JsonPresentationFields.IS_DELETED, component.getIsDeleted());
1381         toscaElement.setMetadataValue(JsonPresentationFields.ICON, component.getIcon());
1382         toscaElement.setMetadataValue(JsonPresentationFields.DESCRIPTION, component.getDescription());
1383         toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags());
1384         toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID());
1385         toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
1386         toscaElement.setMetadataValue(JsonPresentationFields.MODEL, component.getModel());
1387         toscaElement.setModel(component.getModel());
1388         for (final String key : component.getCategorySpecificMetadata().keySet()) {
1389             toscaElement.setMetadataValue(key, component.getCategorySpecificMetadata().get(key));
1390         }
1391         final List<DataTypeDefinition> dataTypes = component.getDataTypes();
1392         if (CollectionUtils.isNotEmpty(dataTypes)) {
1393             toscaElement
1394                 .setDataTypes(dataTypes.stream().collect(Collectors.toMap(DataTypeDefinition::getName, dataTypeDefinition -> dataTypeDefinition)));
1395         }
1396     }
1397
1398     private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {
1399         List<ComponentInstance> componentInstances = new ArrayList<>();
1400         ComponentInstance currComponentInstance;
1401         Map<String, CINodeFilterDataDefinition> nodeFilterComponents = topologyTemplate.getNodeFilterComponents();
1402         for (Map.Entry<String, ComponentInstanceDataDefinition> entry : topologyTemplate.getComponentInstances().entrySet()) {
1403             String key = entry.getKey();
1404             currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key));
1405             if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) {
1406                 List<GroupInstance> groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream()
1407                     .map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList());
1408                 currComponentInstance.setGroupInstances(groupInstances);
1409             }
1410             setComponentInstanceSource(currComponentInstance, component);
1411             if (MapUtils.isNotEmpty(nodeFilterComponents) && nodeFilterComponents.containsKey(key)) {
1412                 currComponentInstance.setNodeFilter(nodeFilterComponents.get(key));
1413             }
1414             if (topologyTemplate.getInstProperties() != null && topologyTemplate.getInstProperties().containsKey(key)
1415                 && topologyTemplate.getInstProperties().get(key) != null) {
1416                 List<PropertyDefinition> instanceProps = topologyTemplate.getInstProperties().get(key).getMapToscaDataDefinition().entrySet().stream()
1417                     .map(e -> new PropertyDefinition(e.getValue())).collect(Collectors.toList());
1418                 currComponentInstance.setProperties(instanceProps);
1419             }
1420             if (topologyTemplate.getInstInputs() != null && topologyTemplate.getInstInputs().containsKey(key)
1421                 && topologyTemplate.getInstInputs().get(key) != null) {
1422                 List<InputDefinition> instanceInputs = topologyTemplate.getInstInputs().get(key).getMapToscaDataDefinition().entrySet().stream()
1423                     .map(e -> new InputDefinition(e.getValue())).collect(Collectors.toList());
1424                 currComponentInstance.setInputs(instanceInputs);
1425             }
1426             final Map<String, MapAttributesDataDefinition> instAttributes = topologyTemplate.getInstAttributes();
1427             if (instAttributes != null && instAttributes.containsKey(key) && instAttributes.get(key) != null) {
1428                 currComponentInstance.setAttributes(
1429                     instAttributes.get(key).getMapToscaDataDefinition().values().stream().map(AttributeDefinition::new).collect(Collectors.toList()));
1430             }
1431             if (topologyTemplate.getComponentInstInterfaces() != null && topologyTemplate.getComponentInstInterfaces().containsKey(key)
1432                 && topologyTemplate.getComponentInstInterfaces().get(key) != null) {
1433                 Map<String, Object> interfacesMap = topologyTemplate.getComponentInstInterfaces().get(key).getMapToscaDataDefinition().entrySet()
1434                     .stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
1435                 currComponentInstance.setInterfaces(interfacesMap);
1436             }
1437             componentInstances.add(currComponentInstance);
1438         }
1439         component.setComponentInstances(componentInstances);
1440     }
1441
1442     public static List<ComponentInstance> getComponentInstancesFromMapObject(
1443         Map<String, ComponentInstanceDataDefinition> componentInstancesDefinitionMap, Component component) {
1444         List<ComponentInstance> componentInstances = new ArrayList<>();
1445         ComponentInstance currComponentInstance;
1446         for (Map.Entry<String, ComponentInstanceDataDefinition> entry : componentInstancesDefinitionMap.entrySet()) {
1447             String key = entry.getKey();
1448             currComponentInstance = new ComponentInstance(componentInstancesDefinitionMap.get(key));
1449             setComponentInstanceSource(currComponentInstance, component);
1450             componentInstances.add(currComponentInstance);
1451         }
1452         return componentInstances;
1453     }
1454
1455     private static void setComponentInstanceSource(ComponentInstance currComponentInstance, Component component) {
1456         if (Objects.isNull(currComponentInstance.getCreatedFrom())) {
1457             if (ComponentTypeEnum.RESOURCE.equals(component.getComponentType())) {
1458                 Resource resource = (Resource) component;
1459                 if (isFromCsar(resource)) {
1460                     currComponentInstance.setCreatedFrom(CreatedFrom.CSAR);
1461                 } else {
1462                     currComponentInstance.setCreatedFrom(CreatedFrom.UI);
1463                 }
1464             }
1465         }
1466     }
1467
1468     private static boolean isFromCsar(Resource resource) {
1469         return resource.getResourceType() == ResourceTypeEnum.VF || resource.getResourceType() == ResourceTypeEnum.CVFC
1470             || resource.getResourceType() == ResourceTypeEnum.PNF;
1471     }
1472
1473     private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) {
1474         if (topologyTemplate.getInstInputs() != null) {
1475             Map<String, List<ComponentInstanceInput>> inputs = new HashMap<>();
1476             for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstInputs().entrySet()) {
1477                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1478                     String key = entry.getKey();
1479                     List<ComponentInstanceInput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1480                         .map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList());
1481                     inputs.put(key, componentInstanceAttributes);
1482                 }
1483             }
1484             component.setComponentInstancesInputs(inputs);
1485         }
1486     }
1487
1488     private static void setComponentInstancesOutputsToComponent(final TopologyTemplate topologyTemplate, final Component component) {
1489         if (topologyTemplate.getInstOutputs() != null) {
1490             final Map<String, List<ComponentInstanceOutput>> outputs = new HashMap<>();
1491             for (final Entry<String, MapAttributesDataDefinition> entry : topologyTemplate.getInstOutputs().entrySet()) {
1492                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1493                     final String key = entry.getKey();
1494                     final List<ComponentInstanceOutput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1495                         .map(e -> new ComponentInstanceOutput(e.getValue())).collect(Collectors.toList());
1496                     outputs.put(key, componentInstanceAttributes);
1497                 }
1498             }
1499             component.setComponentInstancesOutputs(outputs);
1500         }
1501     }
1502
1503     private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) {
1504         if (topologyTemplate.getInstProperties() != null) {
1505             Map<String, List<ComponentInstanceProperty>> properties = new HashMap<>();
1506             for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstProperties().entrySet()) {
1507                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1508                     String key = entry.getKey();
1509                     List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1510                         .map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue()))).collect(Collectors.toList());
1511                     properties.put(key, componentInstanceAttributes);
1512                 }
1513             }
1514             component.setComponentInstancesProperties(properties);
1515         }
1516     }
1517
1518     public static Map<String, List<ComponentInstanceAttribute>> getComponentInstancesAttributes(
1519         Map<String, MapAttributesDataDefinition> mapAttributesDataDefinitionMap) {
1520         Map<String, List<ComponentInstanceAttribute>> attributes = new HashMap<>();
1521         for (Map.Entry<String, MapAttributesDataDefinition> entry : mapAttributesDataDefinitionMap.entrySet()) {
1522             if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1523                 String key = entry.getKey();
1524                 List<ComponentInstanceAttribute> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1525                     .map(e -> new ComponentInstanceAttribute(new AttributeDefinition(e.getValue()))).collect(Collectors.toList());
1526                 attributes.put(key, componentInstanceAttributes);
1527             }
1528         }
1529         return attributes;
1530     }
1531
1532     private static void setComponentInstancesInterfacesToComponent(TopologyTemplate topologyTemplate, Component component) {
1533         if (topologyTemplate.getInstInterfaces() != null) {
1534             Map<String, List<ComponentInstanceInterface>> interfaces = new HashMap<>();
1535             for (Map.Entry<String, MapInterfaceInstanceDataDefinition> entry : topologyTemplate.getInstInterfaces().entrySet()) {
1536                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1537                     String key = entry.getKey();
1538                     List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1539                         .map(e -> new ComponentInstanceInterface(e.getKey(), e.getValue())).collect(Collectors.toList());
1540                     interfaces.put(key, componentInstanceInterfaces);
1541                 }
1542             }
1543             component.setComponentInstancesInterfaces(interfaces);
1544         } else if (topologyTemplate.getComponentInstInterfaces() != null) {
1545             Map<String, List<ComponentInstanceInterface>> interfaces = new HashMap<>();
1546             for (Map.Entry<String, MapInterfaceDataDefinition> entry : topologyTemplate.getComponentInstInterfaces().entrySet()) {
1547                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1548                     String key = entry.getKey();
1549                     List<ComponentInstanceInterface> componentInstanceInterfaces = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1550                         .map(e -> new ComponentInstanceInterface(e.getKey(), e.getValue())).collect(Collectors.toList());
1551                     interfaces.put(key, componentInstanceInterfaces);
1552                 }
1553             }
1554             component.setComponentInstancesInterfaces(interfaces);
1555         }
1556     }
1557
1558     private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) {
1559         if (topologyTemplate.getInstAttributes() != null) {
1560             Map<String, List<ComponentInstanceAttribute>> attributes = new HashMap<>();
1561             for (Map.Entry<String, MapAttributesDataDefinition> entry : topologyTemplate.getInstAttributes().entrySet()) {
1562                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1563                     String key = entry.getKey();
1564                     List<ComponentInstanceAttribute> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream()
1565                         .map(e -> new ComponentInstanceAttribute(new AttributeDefinition(e.getValue()))).collect(Collectors.toList());
1566                     attributes.put(key, componentInstanceAttributes);
1567                 }
1568             }
1569             component.setComponentInstancesAttributes(attributes);
1570         }
1571     }
1572
1573     public static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
1574         if (topologyTemplate.getCalculatedRequirements() != null) {
1575             // Requirements of component organized by capability
1576             Map<String, List<RequirementDefinition>> instanceRequiermentsFromMapObject = getInstanceRequirementsFromMapObject(
1577                 topologyTemplate.getCalculatedRequirements(), component);
1578             component.setRequirements(instanceRequiermentsFromMapObject);
1579         }
1580     }
1581
1582     public static Map<String, List<RequirementDefinition>> getInstanceRequirementsFromMapObject(
1583         Map<String, MapListRequirementDataDefinition> mapListRequirements, Component component) {
1584         // Requirements of component organized by capability
1585         Map<String, List<RequirementDefinition>> instancesRequirements = new HashMap<>();
1586         if (mapListRequirements != null) {
1587             Map<String, ComponentInstance> instancesMap = new HashMap<>();
1588             for (ComponentInstance currInstance : component.getComponentInstances()) {
1589                 instancesMap.put(currInstance.getUniqueId(), currInstance);
1590             }
1591             for (Map.Entry<String, MapListRequirementDataDefinition> entry : mapListRequirements.entrySet()) {
1592                 String instanceId = entry.getKey();
1593                 // Requirements of instance organized by capability
1594                 Map<String, ListRequirementDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1595                 if (capsMapList != null) {
1596                     for (Entry<String, ListRequirementDataDefinition> entryTypeList : capsMapList.entrySet()) {
1597                         String capabilityType = entryTypeList.getKey();
1598                         List<RequirementDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
1599                             .map(RequirementDefinition::new).collect(Collectors.toList());
1600                         if (instancesRequirements.containsKey(capabilityType)) {
1601                             instancesRequirements.get(capabilityType).addAll(caps);
1602                         } else {
1603                             instancesRequirements.put(capabilityType, caps);
1604                         }
1605                         if (MapUtils.isEmpty(instancesMap.get(instanceId).getRequirements())) {
1606                             instancesMap.get(instanceId).setRequirements(new HashMap<>());
1607                         }
1608                         instancesMap.get(instanceId).getRequirements().put(capabilityType, new ArrayList<>(caps));
1609                     }
1610                 }
1611             }
1612             component.setRequirements(instancesRequirements);
1613         }
1614         return instancesRequirements;
1615     }
1616
1617     public static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) {
1618         Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1619         if (topologyTemplate.getCalculatedCapabilities() != null) {
1620             // capabilities of component organized by type
1621             Map<String, List<CapabilityDefinition>> instancesCapabilities = new HashMap<>();
1622             Map<String, ComponentInstance> instancesMap = new HashMap<>();
1623             for (ComponentInstance currInstance : component.getComponentInstances()) {
1624                 instancesMap.put(currInstance.getUniqueId(), currInstance);
1625             }
1626             for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1627                 String instanceId = entry.getKey();
1628                 // capabilities of instance organized by type
1629                 Map<String, ListCapabilityDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1630                 if (capsMapList != null) {
1631                     for (Entry<String, ListCapabilityDataDefinition> entryTypeList : capsMapList.entrySet()) {
1632                         String capabilityType = entryTypeList.getKey();
1633                         List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
1634                             .map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList());
1635                         if (instancesCapabilities.containsKey(capabilityType)) {
1636                             instancesCapabilities.get(capabilityType).addAll(caps);
1637                         } else {
1638                             instancesCapabilities.put(capabilityType, caps);
1639                         }
1640                         ComponentInstance instance = instancesMap.get(instanceId);
1641                         if (instance == null) {
1642                             log.error("instance is null for id {} entry {}", instanceId,
1643                                 entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME));
1644                         } else {
1645                             if (MapUtils.isEmpty(instance.getCapabilities())) {
1646                                 instance.setCapabilities(new HashMap<>());
1647                             }
1648                             instance.getCapabilities().put(capabilityType, new ArrayList<>(caps));
1649                         }
1650                     }
1651                 }
1652             }
1653             component.setCapabilities(instancesCapabilities);
1654         }
1655     }
1656
1657     private static void setCapabilitiesToComponent(TopologyTemplate topologyTemplate, Component component) {
1658         Map<String, ListCapabilityDataDefinition> capabilities = topologyTemplate.getCapabilities();
1659         Map<String, MapPropertiesDataDefinition> capabilitiesProperties = topologyTemplate.getCapabilitiesProperties();
1660         Map<String, List<CapabilityDefinition>> allCapabilities = new HashMap<>();
1661         if (MapUtils.isNotEmpty(capabilities)) {
1662             allCapabilities.putAll(groupCapabilityByType(capabilities));
1663         }
1664         if (MapUtils.isNotEmpty(capabilitiesProperties)) {
1665             capabilitiesProperties.forEach((s, capProp) -> {
1666                 String[] result = s.split(CAP_PROP_DELIM);
1667                 if (capProp != null) {
1668                     Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
1669                     if (MapUtils.isNotEmpty(capMap)) {
1670                         List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new)
1671                             .collect(Collectors.toList());
1672                         List<CapabilityDefinition> cap = allCapabilities.get(result[0]);
1673                         if (cap != null) {
1674                             Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
1675                             op.ifPresent(capabilityDefinition -> capabilityDefinition.setProperties(capPropsList));
1676                         }
1677                     }
1678                 }
1679             });
1680         }
1681         Map<String, List<CapabilityDefinition>> componentCapabilities = component.getCapabilities();
1682         if (MapUtils.isNotEmpty(componentCapabilities)) {
1683             mergeCapabilityMap(allCapabilities, componentCapabilities);
1684         }
1685         component.setCapabilities(allCapabilities);
1686     }
1687
1688     private static void mergeCapabilityMap(Map<String, List<CapabilityDefinition>> map1, Map<String, List<CapabilityDefinition>> map2) {
1689         map1.forEach((key1, val1) -> map2.forEach((key2, val2) -> {
1690             if (key1.equals(key2)) {
1691                 val2.addAll(val1);
1692             }
1693         }));
1694         map1.putAll(map2);
1695     }
1696
1697     private static Map<String, List<CapabilityDefinition>> groupCapabilityByType(Map<String, ListCapabilityDataDefinition> capabilities) {
1698         Map<String, List<CapabilityDefinition>> groupedCapabilities = new HashMap<>();
1699         Set<String> typesSet = new HashSet<>();
1700         List<CapabilityDefinition> allCapabilityDefinitions = new ArrayList<>();
1701         for (Entry<String, ListCapabilityDataDefinition> capabilitiesEntry : capabilities.entrySet()) {
1702             typesSet.addAll(capabilitiesEntry.getValue().getListToscaDataDefinition().stream().map(CapabilityDataDefinition::getType)
1703                 .collect(Collectors.toSet()));
1704             allCapabilityDefinitions.addAll(
1705                 capabilitiesEntry.getValue().getListToscaDataDefinition().stream().map(CapabilityDefinition::new).collect(Collectors.toList()));
1706         }
1707         for (String capType : typesSet) {
1708             groupedCapabilities.put(capType,
1709                 allCapabilityDefinitions.stream().filter(capabilityDefinition -> capabilityDefinition.getType().equals(capType))
1710                     .collect(Collectors.toList()));
1711         }
1712         return groupedCapabilities;
1713     }
1714
1715     private static void setRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
1716         Map<String, ListRequirementDataDefinition> requirements = topologyTemplate.getRequirements();
1717         Map<String, List<RequirementDefinition>> componentRequirements = component.getRequirements();
1718         if (MapUtils.isNotEmpty(requirements)) {
1719             if (componentRequirements == null) {
1720                 componentRequirements = new HashMap<>();
1721             }
1722             componentRequirements.putAll(groupRequirementByType(requirements));
1723             component.setRequirements(componentRequirements);
1724         }
1725     }
1726
1727     private static Map<String, List<RequirementDefinition>> groupRequirementByType(Map<String, ListRequirementDataDefinition> requirements) {
1728         Map<String, List<RequirementDefinition>> groupedRequirement = new HashMap<>();
1729         Set<String> typesSet = new HashSet<>();
1730         List<RequirementDefinition> allRequirements = new ArrayList<>();
1731         for (Entry<String, ListRequirementDataDefinition> requirementsEntry : requirements.entrySet()) {
1732             typesSet.addAll(requirementsEntry.getValue().getListToscaDataDefinition().stream().map(RequirementDataDefinition::getCapability)
1733                 .collect(Collectors.toSet()));
1734             allRequirements.addAll(
1735                 requirementsEntry.getValue().getListToscaDataDefinition().stream().map(RequirementDefinition::new).collect(Collectors.toList()));
1736         }
1737         for (String capType : typesSet) {
1738             groupedRequirement.put(capType,
1739                 allRequirements.stream().filter(requirementDefinition -> requirementDefinition.getCapability().equals(capType))
1740                     .collect(Collectors.toList()));
1741         }
1742         return groupedRequirement;
1743     }
1744
1745     private static void setCapabilitiesToComponentAndGroups(TopologyTemplate topologyTemplate, Component component) {
1746         Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1747         if (capabilitiesAndGroupsExist(topologyTemplate, component)) {
1748             Map<String, GroupDefinition> groupsMap = component.getGroups().stream()
1749                 .collect(Collectors.toMap(GroupDefinition::getUniqueId, Function.identity()));
1750             for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1751                 findSetCapabilitiesToComponentAndGroup(calculatedCapProperties, component, groupsMap, entry);
1752             }
1753         }
1754     }
1755
1756     private static boolean capabilitiesAndGroupsExist(TopologyTemplate topologyTemplate, Component component) {
1757         return MapUtils.isNotEmpty(topologyTemplate.getCalculatedCapabilities()) && CollectionUtils.isNotEmpty(component.getGroups());
1758     }
1759
1760     private static void findSetCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component,
1761                                                                Map<String, GroupDefinition> groupsMap,
1762                                                                Map.Entry<String, MapListCapabilityDataDefinition> entry) {
1763         String uniqueId = entry.getKey();
1764         if (groupsMap.containsKey(uniqueId)) {
1765             setCapabilitiesToComponentAndGroup(calculatedCapProperties, component, entry, groupsMap.get(uniqueId));
1766         } else {
1767             log.warn("The group with uniqueId {} was not found", uniqueId);
1768         }
1769     }
1770
1771     private static void setCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component,
1772                                                            Map.Entry<String, MapListCapabilityDataDefinition> entry, GroupDefinition group) {
1773         for (Entry<String, ListCapabilityDataDefinition> entryTypeList : entry.getValue().getMapToscaDataDefinition().entrySet()) {
1774             String capabilityType = entryTypeList.getKey();
1775             List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream()
1776                 .map(cap -> mergeInstCapabiltyWithProperty(cap, group.getUniqueId(), calculatedCapProperties)).collect(Collectors.toList());
1777             if (component.getCapabilities().containsKey(capabilityType)) {
1778                 component.getCapabilities().get(capabilityType).addAll(caps);
1779             } else {
1780                 component.getCapabilities().put(capabilityType, caps);
1781             }
1782             group.getCapabilities().put(capabilityType, Lists.newArrayList(caps));
1783         }
1784     }
1785
1786     private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String ownerId,
1787                                                                        Map<String, MapCapabilityProperty> calculatedCapProperties) {
1788         CapabilityDefinition capability = new CapabilityDefinition(cap);
1789         if (calculatedCapProperties != null) {
1790             MapCapabilityProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(ownerId);
1791             if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) {
1792                 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition();
1793                 toscaCapPropMap.forEach((keyPath, capProp) -> findConvertSetProperties(cap, ownerId, capability, keyPath, capProp));
1794             }
1795         }
1796         return capability;
1797     }
1798
1799     private static void findConvertSetProperties(CapabilityDataDefinition cap, String primaryPathKey, CapabilityDefinition capability, String path,
1800                                                  MapPropertiesDataDefinition capProp) {
1801         // format key of capability properties :
1802
1803         // VF instance in service : instanceId#ownerId#type#capName
1804
1805         // VFC instance in VF : instanceId#type#capName -> instanceId=ownerId
1806
1807         // Group in service : groupName#ownerId#type#capName
1808
1809         // Group in VF : groupName#type#capName -> groupName=ownerId
1810         String[] result = path.split(CAP_PROP_DELIM);
1811         if (result.length < 4) {
1812             log.debug("wrong key format for capabilty, key {}", capProp);
1813             return;
1814         }
1815         if (relatedPropertiesExist(cap, primaryPathKey, capProp, result)) {
1816             capability.setProperties(
1817                 capProp.getMapToscaDataDefinition().values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()));
1818         }
1819     }
1820
1821     private static boolean relatedPropertiesExist(CapabilityDataDefinition cap, String primaryPathKey, MapPropertiesDataDefinition capProp,
1822                                                   String[] result) {
1823         return capProp != null && MapUtils.isNotEmpty(capProp.getMapToscaDataDefinition()) && areRelatedProperties(cap, primaryPathKey, result);
1824     }
1825
1826     private static boolean areRelatedProperties(CapabilityDataDefinition cap, String primaryPathKey, String[] result) {
1827         int primaryKeyIndex = 0;
1828         int ownerIndex = 1;
1829         int typeIndex = result.length - 2;
1830         int nameIndex = result.length - 1;
1831         return result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex])
1832             && primaryPathKey.equals(result[primaryKeyIndex]);
1833     }
1834
1835     private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1836         Map<String, ComponentInstanceDataDefinition> componentInstances = new HashMap<>();
1837         ComponentInstanceDataDefinition convertedInstance;
1838         if (component.getComponentInstances() != null) {
1839             for (ComponentInstance instance : component.getComponentInstances()) {
1840                 convertedInstance = new ComponentInstanceDataDefinition(instance);
1841                 if (instance.getGroupInstances() != null) {
1842                     MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition();
1843                     groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(GroupInstanceDataDefinition::new)
1844                         .collect(Collectors.toMap(GroupInstanceDataDefinition::getName, Function.identity())));
1845                     if (topologyTemplate.getInstGroups() == null) {
1846                         topologyTemplate.setInstGroups(new HashMap<>());
1847                     }
1848                     topologyTemplate.getInstGroups().put(instance.getUniqueId(), groupsMap);
1849                 }
1850                 componentInstances.put(instance.getUniqueId(), convertedInstance);
1851             }
1852         }
1853         topologyTemplate.setComponentInstances(componentInstances);
1854     }
1855
1856     private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1857         if (component.getComponentInstancesInputs() != null) {
1858             topologyTemplate.setInstInputs(new HashMap<>());
1859             MapPropertiesDataDefinition inputsMap;
1860             for (Entry<String, List<ComponentInstanceInput>> entry : component.getComponentInstancesInputs().entrySet()) {
1861                 inputsMap = new MapPropertiesDataDefinition();
1862                 inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new)
1863                     .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
1864                 topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap);
1865             }
1866         }
1867     }
1868
1869     private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1870         if (component.getComponentInstancesProperties() != null) {
1871             topologyTemplate.setInstProperties(new HashMap<>());
1872             MapPropertiesDataDefinition propertiesMap;
1873             for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesProperties().entrySet()) {
1874                 propertiesMap = new MapPropertiesDataDefinition();
1875                 propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new)
1876                     .collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
1877                 topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap);
1878             }
1879         }
1880     }
1881
1882     private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1883         List<ComponentInstance> componentInstances = component.getComponentInstances();
1884         if (componentInstances != null) {
1885             topologyTemplate.setInstanceArtifacts(new HashMap<>());
1886             topologyTemplate.setInstDeploymentArtifacts(new HashMap<>());
1887             for (ComponentInstance ci : componentInstances) {
1888                 Map<String, ArtifactDefinition> artifacts = ci.getArtifacts();
1889                 if (artifacts != null) {
1890                     Map<String, ArtifactDataDefinition> mapToscaDataDefinitionArtifact = artifacts.entrySet().stream()
1891                         .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1892                     MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact);
1893                     topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact);
1894                 }
1895                 Map<String, ArtifactDefinition> deplArtifacts = ci.getDeploymentArtifacts();
1896                 if (deplArtifacts != null) {
1897                     Map<String, ArtifactDataDefinition> mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream()
1898                         .collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1899                     MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact);
1900                     topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact);
1901                 }
1902             }
1903         }
1904     }
1905
1906     private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1907         if (component.getComponentInstancesAttributes() != null) {
1908             topologyTemplate.setInstAttributes(new HashMap<>());
1909             for (Entry<String, List<ComponentInstanceAttribute>> entry : component.getComponentInstancesAttributes().entrySet()) {
1910                 final MapAttributesDataDefinition attributesMap = new MapAttributesDataDefinition();
1911                 attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(AttributeDefinition::new)
1912                     .collect(Collectors.toMap(AttributeDefinition::getName, Function.identity(), (entity1, entity2) -> entity1)));
1913                 topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap);
1914             }
1915         }
1916     }
1917
1918     public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) {
1919         ComponentMetadataData metadata;
1920         switch (vertex.getType()) {
1921             case SERVICE:
1922                 metadata = new ServiceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
1923                 break;
1924             case RESOURCE:
1925                 metadata = new ResourceMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
1926                 break;
1927             case PRODUCT:
1928                 metadata = new ProductMetadataData(new GraphPropertiesDictionaryExtractor(vertex.getMetadataJson()));
1929                 break;
1930             default:
1931                 throw new StorageException(JanusGraphOperationStatus.INVALID_TYPE);
1932         }
1933         metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId());
1934         metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
1935         metadata.getMetadataDataDefinition().setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID));
1936         metadata.getMetadataDataDefinition().setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE));
1937         return metadata;
1938     }
1939
1940     public static ComponentMetadataDataDefinition convertToComponentMetadataDataDefinition(GraphVertex vertex) {
1941         ComponentMetadataDataDefinition metadata;
1942         switch (vertex.getType()) {
1943             case SERVICE:
1944                 metadata = new ServiceMetadataDataDefinition(new JsonPresentationFieldsExtractor(vertex.getMetadataJson()));
1945                 break;
1946             case RESOURCE:
1947                 metadata = new ResourceMetadataDataDefinition(new JsonPresentationFieldsExtractor(vertex.getMetadataJson()));
1948                 break;
1949             case PRODUCT:
1950                 metadata = new ProductMetadataDataDefinition(new JsonPresentationFieldsExtractor(vertex.getMetadataJson()));
1951                 break;
1952             default:
1953                 throw new StorageException(JanusGraphOperationStatus.INVALID_TYPE);
1954         }
1955         metadata.setUniqueId(vertex.getUniqueId());
1956         metadata.setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
1957         metadata.setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID));
1958         metadata.setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE));
1959         return metadata;
1960     }
1961
1962     public static List<GroupDefinition> convertToGroupDefinitions(Map<String, GroupDataDefinition> groups) {
1963         List<GroupDefinition> groupDefinitions = new ArrayList<>();
1964         if (MapUtils.isNotEmpty(groups)) {
1965             groupDefinitions = groups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
1966         }
1967         return groupDefinitions;
1968     }
1969
1970     public static Map<String, MapCapabilityProperty> extractCapabilityProperteisFromInstances(List<ComponentInstance> instances, boolean fromCsar) {
1971         return instances.stream().collect(Collectors.toMap(ComponentInstanceDataDefinition::getUniqueId,
1972             ci -> convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), ci.getUniqueId(), fromCsar)));
1973     }
1974
1975     public static Map<String, MapCapabilityProperty> extractCapabilityPropertiesFromGroups(List<GroupDefinition> groups, boolean fromCsar) {
1976         if (CollectionUtils.isNotEmpty(groups)) {
1977             return groups.stream().collect(Collectors
1978                 .toMap(GroupDefinition::getUniqueId, g -> convertToMapOfMapCapabiltyProperties(g.getCapabilities(), g.getUniqueId(), fromCsar)));
1979         }
1980         return Maps.newHashMap();
1981     }
1982
1983     public static Map<String, MapListCapabilityDataDefinition> extractCapabilitiesFromGroups(final List<GroupDefinition> groupDefinitions) {
1984         Map<String, MapListCapabilityDataDefinition> calculatedCapabilities = Maps.newHashMap();
1985         for (GroupDefinition groupDefinition : groupDefinitions) {
1986             calculatedCapabilities
1987                 .put(groupDefinition.getUniqueId(), new MapListCapabilityDataDefinition(buildMapOfListsOfCapabilities(groupDefinition)));
1988         }
1989         return calculatedCapabilities;
1990     }
1991
1992     private static Map<String, ListCapabilityDataDefinition> buildMapOfListsOfCapabilities(GroupDefinition groupDefinition) {
1993         return groupDefinition.getCapabilities().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey,
1994             e -> new ListCapabilityDataDefinition(e.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList()))));
1995     }
1996 }