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