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