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