catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/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.T
  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.jsontitan.utils;
  22
  23 import com.google.common.collect.Lists;
  24 import com.google.common.collect.Maps;
  25 import org.apache.commons.collections.CollectionUtils;
  26 import org.apache.commons.collections.MapUtils;
  27 import org.apache.commons.lang.BooleanUtils;
  28 import org.apache.commons.lang3.StringUtils;
  29 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  30 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  31 import org.openecomp.sdc.be.datatypes.elements.*;
  32 import org.openecomp.sdc.be.datatypes.elements.MapCapabilityProperty;
  33 import org.openecomp.sdc.be.datatypes.elements.MapListCapabilityDataDefinition;
  34 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  35 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  36 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  37 import org.openecomp.sdc.be.model.*;
  38 import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType;
  39 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
  40 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
  41 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
  42 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
  43 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
  44 import org.openecomp.sdc.be.resources.data.ProductMetadataData;
  45 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  46 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
  47 import org.openecomp.sdc.common.log.wrappers.Logger;
  48
  49 import java.util.*;
  50 import java.util.Map.Entry;
  51 import java.util.function.Function;
  52 import java.util.stream.Collectors;
  53
  54 public class ModelConverter {
  55     public static final String CAP_PROP_DELIM = "#";
  56     private static final Logger log = Logger.getLogger(ModelConverter.class);
  57
  58     @SuppressWarnings("unchecked")
  59     public static <T extends ToscaElement> T convertToToscaElement(Component component) {
  60         if (isAtomicComponent(component)) {
  61             return (T) convertToNodeType(component);
  62         }
  63         return (T) convertToTopologyTemplate(component);
  64     }
  65
  66     @SuppressWarnings("unchecked")
  67     public static <T extends Component> T convertFromToscaElement(ToscaElement toscaElement) {
  68         switch (toscaElement.getComponentType()) {
  69         case RESOURCE:
  70             return (T) convertToResource(toscaElement);
  71         case SERVICE:
  72         case PRODUCT:
  73             return (T) convertToService(toscaElement);
  74         default:
  75             return null;
  76         }
  77     }
  78
  79     public static boolean isAtomicComponent(Component component) {
  80         ComponentTypeEnum componentType = component.getComponentType();
  81         if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
  82             return false;
  83         }
  84         Resource resource = (Resource) component;
  85         ResourceTypeEnum resType = resource.getResourceType();
  86         return isAtomicComponent(resType);
  87     }
  88
  89     public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
  90         if (resourceType == null) {
  91             return false;
  92         }
  93         return resourceType.isAtomicType();
  94     }
  95
  96     // **********************************************************
  97     public static VertexTypeEnum getVertexType(Component component) {
  98         VertexTypeEnum vertexType;
  99         if (isAtomicComponent(component)) {
 100             vertexType = VertexTypeEnum.NODE_TYPE;
 101         } else {
 102             vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
 103         }
 104         return vertexType;
 105     }
 106
 107     public static VertexTypeEnum getVertexType(String resourceTypeName) {
 108         VertexTypeEnum vertexType = null;
 109         ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName);
 110         if (isAtomicComponent(resourceType)) {
 111             vertexType = VertexTypeEnum.NODE_TYPE;
 112         } else {
 113             vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
 114         }
 115         return vertexType;
 116     }
 117
 118
 119
 120         private static Service convertToService(ToscaElement toscaElement) {
 121                 Service service = new Service();
 122                 convertComponentFields(service, toscaElement);
 123
 124         convertServiceSpecificFields(toscaElement, service);
 125
 126         TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
 127
 128         convertComponentInstances(topologyTemplate, service);
 129
 130         convertInputs(topologyTemplate, service);
 131
 132         convertGroups(topologyTemplate, service);
 133
 134                 setCapabilitiesToComponentAndGroups(topologyTemplate, service);
 135
 136         convertPolicies(topologyTemplate, service);
 137
 138         convertRelations(topologyTemplate, service);
 139
 140         convertArtifacts(topologyTemplate, service);
 141
 142         convertServiceApiArtifacts(topologyTemplate, service);
 143
 144         convertServicePaths(topologyTemplate, service);
 145
 146         return service;
 147     }
 148
 149         private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) {
 150                 service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE));
 151                 service.setDistributionStatus(DistributionStatusEnum
 152                                 .findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
 153                 service.setEcompGeneratedNaming(
 154                                 (Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
 155                 service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY,
 156                                 StringUtils.EMPTY));
 157                 service.setEnvironmentContext(
 158                                 (String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT));
 159                 service.setInstantiationType((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.INSTANTIATION_TYPE, StringUtils.EMPTY));
 160         }
 161
 162     private static Resource convertToResource(ToscaElement toscaElement) {
 163         Resource resource = new Resource();
 164         convertComponentFields(resource, toscaElement);
 165
 166         resource.setResourceType(toscaElement.getResourceType());
 167         if (toscaElement.getToscaType() == ToscaElementTypeEnum.NODE_TYPE) {
 168             NodeType nodeType = (NodeType) toscaElement;
 169             resource.setDerivedFrom(nodeType.getDerivedFrom());
 170             resource.setDerivedList(nodeType.getDerivedList());
 171             resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
 172             convertAttributes(nodeType, resource);
 173             convertCapabilities(nodeType, resource);
 174             convertRequirements(nodeType, resource);
 175             convertInterfaces(nodeType, resource);
 176
 177                 } else {
 178                         TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
 179                         if (resource.getResourceType() == ResourceTypeEnum.VF) {
 180                                 resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
 181                                 resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
 182                                 resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
 183
 184             }
 185             convertComponentInstances(topologyTemplate, resource);
 186             convertRelations(topologyTemplate, resource);
 187             convertInputs(topologyTemplate, resource);
 188             convertGroups(topologyTemplate, resource);
 189                         setCapabilitiesToComponentAndGroups(topologyTemplate, resource);
 190             convertPolicies(topologyTemplate, resource);
 191         }
 192         convertArtifacts(toscaElement, resource);
 193         convertAdditionalInformation(toscaElement, resource);
 194
 195         return resource;
 196     }
 197
 198     private static void convertAttributes(NodeType nodeType, Resource resource) {
 199         Map<String, PropertyDataDefinition> attributes = nodeType.getAttributes();
 200         if (attributes != null) {
 201             List<PropertyDefinition> attrs = attributes.values().stream().map(dataDef -> ModelConverter.fromDataDefinition(resource.getUniqueId(), dataDef)).collect(Collectors.toList());
 202             resource.setAttributes(attrs);
 203         }
 204     }
 205
 206     private static PropertyDefinition fromDataDefinition(String resourceId, PropertyDataDefinition dataDefinition) {
 207         PropertyDefinition attributeDefinition = new PropertyDefinition(dataDefinition);
 208         attributeDefinition.setParentUniqueId(resourceId);
 209         return attributeDefinition;
 210     }
 211
 212     private static void convertInterfaces(NodeType nodeType, Resource resource) {
 213         Map<String, InterfaceDataDefinition> interfaceArtifacts = nodeType.getInterfaceArtifacts();
 214         if (interfaceArtifacts != null) {
 215             Map<String, InterfaceDefinition> interfaces = interfaceArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue())));
 216             resource.setInterfaces(interfaces);
 217         }
 218     }
 219
 220     /**
 221      * Converts component instances of topology template to component instances of resource
 222      *
 223      * @param topologyTemplate
 224      * @param component
 225      */
 226     public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) {
 227
 228         if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) {
 229
 230             setComponentInstancesAttributesToComponent(topologyTemplate, component);
 231
 232             setComponentInstancesPropertiesToComponent(topologyTemplate, component);
 233
 234             setComponentInstancesInputsToComponent(topologyTemplate, component);
 235
 236             setComponentInstancesToComponent(topologyTemplate, component);
 237
 238             setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component);
 239
 240             setComponentInstancesRequirementsToComponent(topologyTemplate, component);
 241
 242             setComponentInstancesArtifactsToComponent(topologyTemplate, component);
 243
 244         }
 245     }
 246
 247     private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) {
 248         Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts();
 249         Map<String, MapArtifactDataDefinition> instanceArtifacts = topologyTemplate.getInstanceArtifacts();
 250
 251         List<ComponentInstance> instances = component.getComponentInstances();
 252         if (instDeploymentArtifacts != null && instances != null) {
 253             instDeploymentArtifacts.entrySet().forEach(e -> {
 254                 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
 255                 if (ci.isPresent()) {
 256                     Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
 257                     Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
 258
 259                     ci.get().setDeploymentArtifacts(deplArt);
 260                 }
 261             });
 262         }
 263         if (instanceArtifacts != null && instances != null) {
 264             instanceArtifacts.entrySet().forEach(e -> {
 265                 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
 266                 if (ci.isPresent()) {
 267                     Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
 268                     Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
 269
 270                     ci.get().setArtifacts(deplArt);
 271                 }
 272             });
 273         }
 274
 275     }
 276
 277     public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) {
 278
 279         if (!CollectionUtils.isEmpty(component.getComponentInstances())) {
 280
 281             setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate);
 282
 283             setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate);
 284
 285             setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate);
 286
 287             setComponentInstancesToTopologyTemplate(component, topologyTemplate);
 288
 289             setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate);
 290         }
 291     }
 292
 293     public static void convertRelations(TopologyTemplate topologyTemplate, Component component) {
 294         Map<String, RelationshipInstDataDefinition> relations = topologyTemplate.getRelations();
 295         List<RequirementCapabilityRelDef> componentRelations;
 296         if (relations != null && !relations.isEmpty()) {
 297             componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList());
 298
 299         } else {
 300             componentRelations = new ArrayList<>();
 301         }
 302         component.setComponentInstancesRelations(componentRelations);
 303
 304     }
 305
 306     public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) {
 307         RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
 308         requirementCapabilityRelDef.setFromNode(relation.getFromId());
 309         requirementCapabilityRelDef.setToNode(relation.getToId());
 310         requirementCapabilityRelDef.setOriginUI(BooleanUtils.isTrue(relation.isOriginUI()));
 311
 312         CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship();
 313         RelationshipInfo relationshipPair = getRelationshipInfo(relation);
 314         rel.setRelation(relationshipPair);
 315         requirementCapabilityRelDef.setRelationships(Arrays.asList(rel));
 316
 317         return requirementCapabilityRelDef;
 318     }
 319
 320     /**
 321      * @param relation
 322      * @return
 323      */
 324     private static RelationshipInfo getRelationshipInfo(RelationshipInstDataDefinition relation) {
 325         RelationshipInfo relationshipPair = new RelationshipInfo();
 326
 327         relationshipPair.setId(relation.getUniqueId());
 328
 329         relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
 330         relationshipPair.setCapabilityUid(relation.getCapabilityId());
 331         relationshipPair.setCapability(relation.getCapability());
 332
 333         relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
 334         relationshipPair.setRequirementUid(relation.getRequirementId());
 335         relationshipPair.setRequirement(relation.getRequirement());
 336
 337         RelationshipImpl relationship = new RelationshipImpl();
 338         relationship.setType(relation.getType());
 339         relationshipPair.setRelationships(relationship);
 340
 341         return relationshipPair;
 342     }
 343
 344
 345     public static List<RelationshipInstDataDefinition> convertRelationToToscaRelation(RequirementCapabilityRelDef relation) {
 346
 347         List<RelationshipInstDataDefinition> relationsList = new ArrayList<>();
 348
 349         List<CapabilityRequirementRelationship> relationship = relation.getRelationships();
 350         relationship.forEach(p -> {
 351             RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition();
 352             requirementCapabilityRelDef.setFromId(relation.getFromNode());
 353             requirementCapabilityRelDef.setToId(relation.getToNode());
 354             requirementCapabilityRelDef.setUniqueId(p.getRelation().getId());
 355             requirementCapabilityRelDef.setCapabilityOwnerId(p.getRelation().getCapabilityOwnerId());
 356             requirementCapabilityRelDef.setCapabilityId(p.getRelation().getCapabilityUid());
 357             requirementCapabilityRelDef.setRequirementOwnerId(p.getRelation().getRequirementOwnerId());
 358             requirementCapabilityRelDef.setRequirementId(p.getRelation().getRequirementUid());
 359             requirementCapabilityRelDef.setRequirement(p.getRelation().getRequirement());
 360             requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType());
 361             requirementCapabilityRelDef.setCapability(p.getRelation().getCapability());
 362
 363             relationsList.add(requirementCapabilityRelDef);
 364         });
 365
 366         return relationsList;
 367     }
 368
 369     private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) {
 370         if(componentInstancesCapabilitiesExist(component) || groupsCapabilitiesExist(component)){
 371             topologyTemplate.setCalculatedCapabilities(new HashMap<>());
 372             topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
 373         }
 374         convertComponentInstancesCapabilities(component, topologyTemplate);
 375         convertGroupsCapabilities(component, topologyTemplate);
 376     }
 377
 378     private static void convertGroupsCapabilities(Component component, TopologyTemplate topologyTemplate) {
 379         if(groupsCapabilitiesExist(component)){
 380             component.getGroups()
 381                     .stream()
 382                     .filter(g -> MapUtils.isNotEmpty(g.getCapabilities()))
 383                     .forEach(g -> addCapabilities(topologyTemplate, g.getCapabilities(), g.getUniqueId()));
 384         }
 385     }
 386
 387     private static void convertComponentInstancesCapabilities(Component component, TopologyTemplate topologyTemplate) {
 388         if (componentInstancesCapabilitiesExist(component)) {
 389             component.getComponentInstances()
 390                     .stream()
 391                     .filter(i -> MapUtils.isNotEmpty(i.getCapabilities()))
 392                     .forEach(i -> addCapabilities(topologyTemplate, i.getCapabilities(), i.getUniqueId()));
 393         }
 394     }
 395
 396     private static void addCapabilities(TopologyTemplate topologyTemplate, Map<String, List<CapabilityDefinition>> capabilities, String ownerId) {
 397         if (MapUtils.isNotEmpty(capabilities)) {
 398             if (topologyTemplate.getCalculatedCapabilities() == null) {
 399                 topologyTemplate.setCalculatedCapabilities(new HashMap<>());
 400             }
 401             topologyTemplate.getCalculatedCapabilities().put(ownerId, convertToMapListCapabiltyDataDefinition(capabilities));
 402             if (topologyTemplate.getCalculatedCapabilitiesProperties() == null) {
 403                 topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
 404             }
 405             topologyTemplate.getCalculatedCapabilitiesProperties().put(ownerId, convertToMapOfMapCapabiltyProperties(capabilities, ownerId));
 406         }
 407     }
 408
 409     private static boolean componentInstancesCapabilitiesExist(Component component) {
 410         return component.getCapabilities() != null && component.getComponentInstances() != null
 411                 && component.getComponentInstances()
 412                 .stream()
 413                 .filter(ci->MapUtils.isNotEmpty(ci.getCapabilities()))
 414                 .findFirst()
 415                 .isPresent();
 416     }
 417     private static boolean groupsCapabilitiesExist(Component component) {
 418         return component.getCapabilities() != null && component.getGroups() != null
 419                 && component.getGroups()
 420                 .stream()
 421                 .filter(g->MapUtils.isNotEmpty(g.getCapabilities()))
 422                 .findFirst()
 423                 .isPresent();
 424     }
 425     public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities, String ownerId) {
 426         return convertToMapOfMapCapabiltyProperties(instCapabilities, ownerId, false);
 427     }
 428
 429         public static MapCapabilityProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> capabilities, String ownerId, boolean fromCsar) {
 430
 431         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
 432                 if(MapUtils.isNotEmpty(capabilities))
 433                         capabilities.forEach((s, caps)-> {
 434
 435                                         if (caps != null && !caps.isEmpty()) {
 436
 437                                                 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
 438
 439                                                 for (CapabilityDefinition cap : caps) {
 440                                                         List<ComponentInstanceProperty> capPrps = cap.getProperties();
 441                                                         if (capPrps != null) {
 442
 443                                                                 for (ComponentInstanceProperty cip : capPrps) {
 444                                                                         dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
 445                                                                 }
 446                                                                 // format key of capability properties :
 447                                                                 // VF instance in service : instanceId#ownerId#type#capName
 448                                                                 // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId
 449
 450                                                                 StringBuilder sb = new StringBuilder(ownerId);
 451                                                                 sb.append(CAP_PROP_DELIM);
 452                                                                 if (fromCsar) {
 453                                                                         sb.append(ownerId);
 454                                                                 } else {
 455                                                                         sb.append(cap.getOwnerId());
 456                                                                 }
 457                                                                 sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
 458                                                                 toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate));
 459                                                         }
 460                                                 }
 461                                         }
 462                                 }
 463                         );
 464         return new MapCapabilityProperty(toscaCapPropMap);
 465     }
 466
 467         private static MapListCapabilityDataDefinition convertToMapListCapabiltyDataDefinition(Map<String, List<CapabilityDefinition>> instCapabilities) {
 468
 469         Map<String, ListCapabilityDataDefinition> mapToscaDataDefinition = new HashMap<>();
 470         for (Entry<String, List<CapabilityDefinition>> instCapability : instCapabilities.entrySet()) {
 471                         mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(CapabilityDataDefinition::new).collect(Collectors.toList())));
 472         }
 473
 474         return new MapListCapabilityDataDefinition(mapToscaDataDefinition);
 475     }
 476
 477     private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) {
 478
 479         if (component.getRequirements() != null && component.getComponentInstances() != null) {
 480             topologyTemplate.setCalculatedRequirements(new HashMap<>());
 481             for (ComponentInstance instance : component.getComponentInstances()) {
 482                 Map<String, List<RequirementDefinition>> instRequirements = instance.getRequirements();
 483                 if (MapUtils.isNotEmpty(instRequirements)) {
 484                     if (topologyTemplate.getCalculatedRequirements() == null) {
 485                         topologyTemplate.setCalculatedRequirements(new HashMap<>());
 486                     }
 487                     topologyTemplate.getCalculatedRequirements().put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements));
 488                 }
 489             }
 490         }
 491     }
 492
 493     private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(Map<String, List<RequirementDefinition>> instRequirements) {
 494
 495         Map<String, ListRequirementDataDefinition> mapToscaDataDefinition = new HashMap<>();
 496         for (Entry<String, List<RequirementDefinition>> instRequirement : instRequirements.entrySet()) {
 497                         mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(instRequirement.getValue().stream().map(RequirementDataDefinition::new).collect(Collectors.toList())));
 498         }
 499
 500         return new MapListRequirementDataDefinition(mapToscaDataDefinition);
 501     }
 502
 503     @SuppressWarnings("unchecked")
 504     private static void convertComponentFields(Component component, ToscaElement toscaElement) {
 505         component.setName(toscaElement.getName());
 506         component.setAllVersions(toscaElement.getAllVersions());
 507         component.setCategories(toscaElement.getCategories());
 508         component.setComponentType(toscaElement.getComponentType());
 509         component.setCreationDate(toscaElement.getCreationDate());
 510         component.setCreatorUserId(toscaElement.getCreatorUserId());
 511         component.setCreatorFullName(toscaElement.getCreatorFullName());
 512         component.setLastUpdateDate(toscaElement.getLastUpdateDate());
 513         component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName());
 514         component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId());
 515         component.setNormalizedName(toscaElement.getNormalizedName());
 516
 517         component.setLifecycleState(toscaElement.getLifecycleState());
 518         component.setVersion(toscaElement.getVersion());
 519         component.setHighestVersion(toscaElement.isHighestVersion());
 520         component.setUniqueId(toscaElement.getUniqueId());
 521         component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME));
 522         component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType());
 523         component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion());
 524
 525         //archive
 526         component.setArchived(toscaElement.isArchived() == null ? false : toscaElement.isArchived());
 527
 528
 529         //component.setArchiveTime(toscaElement.getArchiveTime() == null ? 0L : toscaElement.getArchiveTime());
 530         component.setArchiveTime(toscaElement.getArchiveTime());
 531         component.setVspArchived(toscaElement.isVspArchived() == null ? false : toscaElement.isVspArchived());
 532
 533         if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
 534             Resource resource = (Resource) component;
 535             resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
 536             resource.setToscaResourceName((String) toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
 537             resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME));
 538             resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE));
 539             // field isn't mandatory , but shouldn't be null(should be an empty string instead)
 540             if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null){
 541                 resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER));
 542             } else {
 543                 resource.setResourceVendorModelNumber("");
 544             }
 545         } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
 546             Service service = (Service) component;
 547             if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null){
 548                 service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE));
 549             } else {
 550                 service.setServiceType("");
 551             }
 552             if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null){
 553                 service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE));
 554             } else {
 555                 service.setServiceRole("");
 556             }
 557         }
 558         component.setConformanceLevel((String) toscaElement.getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL));
 559         component.setIcon((String) toscaElement.getMetadataValue(JsonPresentationFields.ICON));
 560         component.setDescription((String) toscaElement.getMetadataValue(JsonPresentationFields.DESCRIPTION));
 561         component.setTags((List<String>) toscaElement.getMetadataValue(JsonPresentationFields.TAGS));
 562         component.setInvariantUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID));
 563         component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID));
 564         component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID));
 565         component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED));
 566
 567
 568         Map<String, PropertyDataDefinition> properties = toscaElement.getProperties();
 569         if (properties != null && !properties.isEmpty()) {
 570                         List<PropertyDefinition> propertiesMap = properties.values().stream().map(PropertyDefinition::new).collect(Collectors.toList());
 571             ((Resource) component).setProperties(propertiesMap);
 572         }
 573
 574         component.setToscaType(toscaElement.getToscaType().getValue());
 575     }
 576
 577     private static NodeType convertToNodeType(Component component) {
 578         Resource resource = (Resource) component;
 579         NodeType nodeType = new NodeType();
 580         nodeType.setDerivedFrom(resource.getDerivedFrom());
 581         nodeType.setDerivedList(resource.getDerivedList());
 582         nodeType.setResourceType(resource.getResourceType());
 583         convertCommonToscaData(component, nodeType);
 584         convertAdditionalInformation(component, nodeType);
 585         convertArtifacts(resource, nodeType);
 586         convertCapabilities(resource, nodeType);
 587         convertRequirements(resource, nodeType);
 588         convertAttributes(resource, nodeType);
 589         convertProperties(resource, nodeType);
 590         convertInterfaces(resource, nodeType);
 591         return nodeType;
 592     }
 593
 594     private static void convertProperties(Resource resource, NodeType nodeType) {
 595         List<PropertyDefinition> properties = resource.getProperties();
 596         if (properties != null && !properties.isEmpty()) {
 597                         Map<String, PropertyDataDefinition> propertiesMap = properties.stream().collect(Collectors.toMap(PropertyDefinition::getName, PropertyDataDefinition::new));
 598             nodeType.setProperties(propertiesMap);
 599         }
 600     }
 601
 602     private static void convertInterfaces(Resource resource, NodeType nodeType) {
 603         Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
 604         if (interfaces != null) {
 605                         Map<String, InterfaceDataDefinition> interfaceArtifacts = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, x -> new InterfaceDataDefinition(x.getValue())));
 606             nodeType.setInterfaceArtifacts(interfaceArtifacts);
 607         }
 608     }
 609
 610     private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) {
 611         List<AdditionalInformationDefinition> additionalInformation = component.getAdditionalInformation();
 612         if (additionalInformation != null) {
 613                         Map<String, AdditionalInfoParameterDataDefinition> addInfo = additionalInformation.stream().collect(Collectors.toMap(AdditionalInformationDefinition::getUniqueId, AdditionalInfoParameterDataDefinition::new));
 614             toscaElement.setAdditionalInformation(addInfo);
 615         }
 616     }
 617
 618     private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) {
 619         Map<String, AdditionalInfoParameterDataDefinition> additionalInformation = toscaElement.getAdditionalInformation();
 620         if (additionalInformation != null) {
 621                         List<AdditionalInformationDefinition> addInfo = additionalInformation.values().stream().map(AdditionalInformationDefinition::new).collect(Collectors.toList());
 622             resource.setAdditionalInformation(addInfo);
 623         }
 624     }
 625
 626     private static void convertArtifacts(ToscaElement toscaElement, Component component) {
 627         Map<String, ArtifactDataDefinition> artifacts = toscaElement.getArtifacts();
 628         Map<String, ArtifactDefinition> copy;
 629         if (artifacts != null) {
 630             copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 631
 632         } else {
 633             copy = new HashMap<>();
 634         }
 635         component.setArtifacts(copy);
 636
 637         Map<String, ArtifactDataDefinition> toscaArtifacts = toscaElement.getToscaArtifacts();
 638         if (toscaArtifacts != null) {
 639             copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 640
 641         } else {
 642             copy = new HashMap<>();
 643         }
 644         component.setToscaArtifacts(copy);
 645
 646         Map<String, ArtifactDataDefinition> deploymentArtifacts = toscaElement.getDeploymentArtifacts();
 647         if (deploymentArtifacts != null) {
 648             copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 649
 650         } else {
 651             copy = new HashMap<>();
 652         }
 653         component.setDeploymentArtifacts(copy);
 654     }
 655
 656     private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) {
 657         Map<String, ArtifactDataDefinition> serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts();
 658         Map<String, ArtifactDefinition> copy;
 659         if (serviceApiArtifacts != null) {
 660             copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 661
 662         } else {
 663             copy = new HashMap<>();
 664         }
 665         service.setServiceApiArtifacts(copy);
 666     }
 667     private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) {
 668         Map<String, ForwardingPathDataDefinition> servicePaths = topologyTemplate.getForwardingPaths();
 669         Map<String, ForwardingPathDataDefinition> copy;
 670         if (servicePaths != null) {
 671             copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
 672
 673         } else {
 674             copy = new HashMap<>();
 675         }
 676         service.setForwardingPaths(copy);
 677     }
 678
 679     private static void convertArtifacts(Component component, ToscaElement toscaElement) {
 680         Map<String, ArtifactDefinition> artifacts = component.getArtifacts();
 681         if (artifacts != null) {
 682             Map<String, ArtifactDataDefinition> copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 683             toscaElement.setArtifacts(copy);
 684         }
 685
 686         Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
 687         if (toscaArtifacts != null) {
 688             Map<String, ArtifactDataDefinition> copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 689             toscaElement.setToscaArtifacts(copy);
 690         }
 691
 692         Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
 693         if (deploymentArtifacts != null) {
 694             Map<String, ArtifactDataDefinition> copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 695             toscaElement.setDeploymentArtifacts(copy);
 696         }
 697     }
 698
 699     private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) {
 700         Map<String, ArtifactDefinition> serviceApiArtifacts = service.getServiceApiArtifacts();
 701         if (serviceApiArtifacts != null) {
 702             Map<String, ArtifactDataDefinition> copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 703             topologyTemplate.setServiceApiArtifacts(copy);
 704         }
 705     }
 706
 707     private static void convertCapabilities(Component component, NodeType toscaElement) {
 708         Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
 709
 710         Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
 711         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
 712
 713         if (capabilities != null && !capabilities.isEmpty()) {
 714                         capabilities.forEach((s, caps) -> {
 715
 716                     if (caps != null && !caps.isEmpty()) {
 717                                                 List<CapabilityDataDefinition> capList = caps.stream().map(CapabilityDataDefinition::new).collect(Collectors.toList());
 718
 719                         ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList);
 720                         toscaCapMap.put(s, listCapabilityDataDefinition);
 721
 722                         for (CapabilityDefinition cap : caps) {
 723                             List<ComponentInstanceProperty> capPrps = cap.getProperties();
 724                             if (capPrps != null && !capPrps.isEmpty()) {
 725
 726                                 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
 727                                 for (ComponentInstanceProperty cip : capPrps) {
 728                                     dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
 729                                 }
 730
 731                                 toscaCapPropMap.put(s + CAP_PROP_DELIM + cap.getName(), dataToCreate);
 732                             }
 733                         }
 734                     }
 735                 }
 736                         );
 737
 738             toscaElement.setCapabilties(toscaCapMap);
 739             toscaElement.setCapabiltiesProperties(toscaCapPropMap);
 740         }
 741     }
 742
 743     private static void convertAttributes(Resource component, NodeType nodeType) {
 744         List<PropertyDefinition> attributes = component.getAttributes();
 745         if (attributes != null) {
 746             Map<String, PropertyDataDefinition> attrsByName = attributes.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
 747             nodeType.setAttributes(attrsByName);
 748         }
 749     }
 750
 751     private static void convertRequirements(Resource component, NodeType nodeType) {
 752         Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
 753
 754         Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
 755
 756         if (requirements != null && !requirements.isEmpty()) {
 757                         requirements.forEach((s, reqs)-> {
 758
 759                     if (reqs != null && !reqs.isEmpty()) {
 760                                                 List<RequirementDataDefinition> reqList = reqs.stream().map(RequirementDataDefinition::new).collect(Collectors.toList());
 761
 762                         ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
 763                         toscaReqMap.put(s, listRequirementDataDefinition);
 764                     }
 765                 }
 766                         );
 767             nodeType.setRequirements(toscaReqMap);
 768         }
 769     }
 770
 771     private static void convertCapabilities(NodeType toscaElement, Component component) {
 772         Map<String, ListCapabilityDataDefinition> toscaCapabilities = toscaElement.getCapabilties();
 773         Map<String, MapPropertiesDataDefinition> toscaCapPropMap = toscaElement.getCapabiltiesProperties();
 774
 775         Map<String, List<CapabilityDefinition>> compCap = new HashMap<>();
 776         if (toscaCapabilities == null || toscaCapabilities.isEmpty())
 777             return;
 778                 toscaCapabilities.forEach((s, cap)-> {
 779
 780                 if (cap != null) {
 781                     List<CapabilityDataDefinition> capDataList = cap.getListToscaDataDefinition();
 782
 783                     if (capDataList != null && !capDataList.isEmpty()) {
 784                                                 List<CapabilityDefinition> capList = capDataList.stream().map(CapabilityDefinition::new).collect(Collectors.toList());
 785                         compCap.put(s, capList);
 786                     }
 787                 }
 788
 789             }
 790                 );
 791         if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) {
 792                         toscaCapPropMap.forEach((s, capProp)-> {
 793                     String[] result = s.split(CAP_PROP_DELIM);
 794                     if (capProp != null) {
 795                         Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
 796
 797                         if (capMap != null && !capMap.isEmpty()) {
 798                                                         List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList());
 799
 800                             List<CapabilityDefinition> cap = compCap.get(result[0]);
 801                             Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
 802                             if (op.isPresent()) {
 803                                 op.get().setProperties(capPropsList);
 804                             }
 805                         }
 806                     }
 807                 }
 808                         );
 809         }
 810
 811         component.setCapabilities(compCap);
 812
 813     }
 814
 815     private static void convertGroups(TopologyTemplate toscaElement, Component component) {
 816         Map<String, GroupDataDefinition> toscaGroups = toscaElement.getGroups();
 817         List<GroupDefinition> groupDefinitions = null;
 818         if (MapUtils.isNotEmpty(toscaGroups)) {
 819                         groupDefinitions = toscaGroups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
 820         }
 821         component.setGroups(groupDefinitions);
 822     }
 823
 824     private static void convertPolicies(TopologyTemplate toscaElement, Component component) {
 825         Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies();
 826         Map<String, PolicyDefinition> policyDefinitions = null;
 827         if (MapUtils.isNotEmpty(policies)) {
 828                         policyDefinitions = policies.values().stream().map(PolicyDefinition::new).collect(Collectors.toMap(PolicyDefinition::getUniqueId, Function.identity()));
 829         }
 830         component.setPolicies(policyDefinitions);
 831     }
 832
 833     private static void convertGroups(Component component, TopologyTemplate toscaElement) {
 834         List<GroupDefinition> groupDefinitions = component.getGroups();
 835         Map<String, GroupDataDefinition> groups = new HashMap<>();
 836
 837         if (groupDefinitions != null && groups.isEmpty()) {
 838                         groups = groupDefinitions.stream().collect(Collectors.toMap(GroupDefinition::getName, GroupDefinition::new));
 839         }
 840         toscaElement.setGroups(groups);
 841     }
 842
 843     private static void convertPolicies(Component component, TopologyTemplate toscaElement) {
 844         Map<String, PolicyDefinition> policyDefinitions = component.getPolicies();
 845         Map<String, PolicyDataDefinition> policies = new HashMap<>();
 846         if (MapUtils.isNotEmpty(policyDefinitions)) {
 847                         policies = policyDefinitions.values().stream().collect((Collectors.toMap(PolicyDefinition::getUniqueId, PolicyDataDefinition::new)));
 848         }
 849         toscaElement.setPolicies(policies);
 850     }
 851
 852     private static void convertRequirements(NodeType toscaElement, Component component) {
 853         Map<String, ListRequirementDataDefinition> toscaRequirements = toscaElement.getRequirements();
 854
 855         Map<String, List<RequirementDefinition>> compReqs = new HashMap<>();
 856         if (toscaRequirements == null || toscaRequirements.isEmpty())
 857             return;
 858                 toscaRequirements.forEach((s, req) -> {
 859
 860                 if (req != null) {
 861                     List<RequirementDataDefinition> reqDataList = req.getListToscaDataDefinition();
 862
 863                     if (reqDataList != null && !reqDataList.isEmpty()) {
 864                                                 List<RequirementDefinition> reqList = reqDataList.stream().map(RequirementDefinition::new).collect(Collectors.toList());
 865                         compReqs.put(s, reqList);
 866                     }
 867                 }
 868             }
 869                 );
 870         component.setRequirements(compReqs);
 871     }
 872
 873     private static TopologyTemplate convertToTopologyTemplate(Component component) {
 874         TopologyTemplate topologyTemplate;
 875         ComponentTypeEnum componentType = component.getComponentType();
 876         topologyTemplate = new TopologyTemplate();
 877
 878         if (componentType == ComponentTypeEnum.RESOURCE) {
 879             Resource resource = (Resource) component;
 880             topologyTemplate.setResourceType(resource.getResourceType());
 881             topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
 882             topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
 883             topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
 884         }
 885         if (componentType == ComponentTypeEnum.SERVICE) {
 886             convertServiceSpecificEntities((Service) component, topologyTemplate);
 887         }
 888         convertCommonToscaData(component, topologyTemplate);
 889         convertArtifacts(component, topologyTemplate);
 890
 891         convertAdditionalInformation(component, topologyTemplate);
 892         convertComponentInstances(component, topologyTemplate);
 893
 894         convertInputs(component, topologyTemplate);
 895         convertCapabilities(component, topologyTemplate);
 896         convertGroups(component, topologyTemplate);
 897         convertPolicies(component, topologyTemplate);
 898         convertRequirements(component, topologyTemplate);
 899         convertRelationsToComposition(component, topologyTemplate);
 900
 901         return topologyTemplate;
 902     }
 903
 904     private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) {
 905         convertServiceMetaData(service, topologyTemplate);
 906         convertServiceApiArtifacts(service, topologyTemplate);
 907         convertServicePaths(service,topologyTemplate);
 908     }
 909
 910     private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) {
 911         Map<String, ForwardingPathDataDefinition> servicePaths = service.getForwardingPaths();
 912         if (servicePaths != null && !servicePaths.isEmpty()) {
 913             Map<String, ForwardingPathDataDefinition> copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
 914             topologyTemplate.setForwardingPaths(copy);
 915         }
 916     }
 917
 918         private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
 919                 if (service.getDistributionStatus() != null) {
 920                         topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS,
 921                                         service.getDistributionStatus().name());
 922                 }
 923                 topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
 924                 topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING,
 925                                 service.isEcompGeneratedNaming());
 926                 topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
 927                 topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext());
 928                 topologyTemplate.setMetadataValue(JsonPresentationFields.INSTANTIATION_TYPE, service.getInstantiationType());
 929
 930     }
 931
 932     private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) {
 933         List<RequirementCapabilityRelDef> componentInstancesRelations = component.getComponentInstancesRelations();
 934         if (componentInstancesRelations != null) {
 935             Map<String, CompositionDataDefinition> compositions = topologyTemplate.getCompositions();
 936             if (compositions == null) {
 937                 compositions = new HashMap<>();
 938             }
 939             CompositionDataDefinition compositionDataDefinition = compositions.get(JsonConstantKeysEnum.COMPOSITION.getValue());
 940             if (compositionDataDefinition == null) {
 941                 compositionDataDefinition = new CompositionDataDefinition();
 942                 compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition);
 943             }
 944
 945             Map<String, RelationshipInstDataDefinition> relations = componentInstancesRelations.stream().flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null)
 946                                         .collect(Collectors.toMap(RelationshipInstDataDefinition::getUniqueId, Function.identity()));
 947             compositionDataDefinition.setRelations(relations);
 948         }
 949     }
 950
 951     private static void convertInputs(Component component, TopologyTemplate topologyTemplate) {
 952         List<InputDefinition> inputsList = component.getInputs();
 953         if (inputsList != null && !inputsList.isEmpty()) {
 954
 955                         Map<String, PropertyDataDefinition> inputsMap = inputsList.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
 956             topologyTemplate.setInputs(inputsMap);
 957         }
 958
 959     }
 960
 961     private static void convertInputs(TopologyTemplate topologyTemplate, Component component) {
 962         Map<String, PropertyDataDefinition> inputsMap = topologyTemplate.getInputs();
 963         if (inputsMap != null && !inputsMap.isEmpty()) {
 964                         List<InputDefinition> inputsList = inputsMap.values()
 965                     .stream()
 966                     .map(InputDefinition::new)
 967                     .collect(Collectors.toList());
 968             component.setInputs(inputsList);
 969         }
 970
 971     }
 972
 973     private static void convertCommonToscaData(Component component, ToscaElement toscaElement) {
 974         toscaElement.setUUID(component.getUUID());
 975         toscaElement.setUniqueId(component.getUniqueId());
 976         toscaElement.setSystemName(component.getSystemName());
 977         toscaElement.setLifecycleState(component.getLifecycleState());
 978         toscaElement.setComponentType(component.getComponentType());
 979         toscaElement.setNormalizedName(component.getNormalizedName());
 980         toscaElement.setMetadataValue(JsonPresentationFields.NAME, component.getName());
 981         toscaElement.setCategories(component.getCategories());
 982         toscaElement.setCreatorUserId(component.getCreatorUserId());
 983         toscaElement.setCreationDate(component.getCreationDate());
 984         toscaElement.setCreatorFullName(component.getCreatorFullName());
 985         toscaElement.setHighestVersion(component.isHighestVersion());
 986         toscaElement.setLastUpdateDate(component.getLastUpdateDate());
 987         toscaElement.setLastUpdaterFullName(component.getLastUpdaterFullName());
 988         toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId());
 989         toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType());
 990         toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion());
 991
 992         //Archive
 993         toscaElement.setArchived(component.isArchived() == null ? false : component.isArchived());
 994         toscaElement.setArchiveTime(component.getArchiveTime() == null ? 0L : component.getArchiveTime());
 995         toscaElement.setVspArchived(component.isVspArchived() == null ? false : component.isVspArchived());
 996
 997         toscaElement.setLifecycleState(component.getLifecycleState());
 998         toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion());
 999         if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
1000             toscaElement.setMetadataValue(JsonPresentationFields.IS_ABSTRACT, ((Resource) component).isAbstract());
1001             toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName());
1002             toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName());
1003             toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease());
1004             // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1005             if (((Resource) component).getResourceVendorModelNumber() != null){
1006                 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber());
1007             } else {
1008                 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, "");
1009             }
1010         } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
1011             // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1012             if (((Service) component).getServiceType() != null){
1013                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType());
1014             } else {
1015                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, "");
1016             }
1017             if (((Service) component).getServiceRole() != null){
1018                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole());
1019             } else {
1020                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, "");
1021             }
1022         }
1023         toscaElement.setMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL, component.getConformanceLevel());
1024         toscaElement.setMetadataValue(JsonPresentationFields.IS_DELETED, component.getIsDeleted());
1025         toscaElement.setMetadataValue(JsonPresentationFields.ICON, component.getIcon());
1026         toscaElement.setMetadataValue(JsonPresentationFields.DESCRIPTION, component.getDescription());
1027         toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags());
1028         toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID());
1029         toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
1030     }
1031
1032
1033
1034     private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {
1035
1036         List<ComponentInstance> componentInstances = new ArrayList<>();
1037         ComponentInstance currComponentInstance;
1038         for (Map.Entry<String, ComponentInstanceDataDefinition> entry : topologyTemplate.getComponentInstances().entrySet()) {
1039             String key = entry.getKey();
1040             currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key));
1041             if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) {
1042                 List<GroupInstance> groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList());
1043                 currComponentInstance.setGroupInstances(groupInstances);
1044             }
1045             componentInstances.add(currComponentInstance);
1046         }
1047         component.setComponentInstances(componentInstances);
1048     }
1049
1050     private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) {
1051         if (topologyTemplate.getInstInputs() != null) {
1052             Map<String, List<ComponentInstanceInput>> inputs = new HashMap<>();
1053             for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstInputs().entrySet()) {
1054                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1055                     String key = entry.getKey();
1056                     List<ComponentInstanceInput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList());
1057                     inputs.put(key, componentInstanceAttributes);
1058                 }
1059             }
1060             component.setComponentInstancesInputs(inputs);
1061         }
1062     }
1063
1064     private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) {
1065         if (topologyTemplate.getInstProperties() != null) {
1066             Map<String, List<ComponentInstanceProperty>> properties = new HashMap<>();
1067             for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstProperties().entrySet()) {
1068                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1069                     String key = entry.getKey();
1070                     List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue())))
1071                             .collect(Collectors.toList());
1072                     properties.put(key, componentInstanceAttributes);
1073                 }
1074             }
1075             component.setComponentInstancesProperties(properties);
1076         }
1077     }
1078
1079     private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) {
1080         if (topologyTemplate.getInstAttributes() != null) {
1081             Map<String, List<ComponentInstanceProperty>> attributes = new HashMap<>();
1082             for (Map.Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstAttributes().entrySet()) {
1083                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1084                     String key = entry.getKey();
1085                     List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new ComponentInstanceProperty(e.getValue())))
1086                             .collect(Collectors.toList());
1087                     attributes.put(key, componentInstanceAttributes);
1088                 }
1089             }
1090             component.setComponentInstancesAttributes(attributes);
1091         }
1092     }
1093
1094     private static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
1095
1096         if (topologyTemplate.getCalculatedRequirements() != null) {
1097             // Requirements of component organized by capability
1098             Map<String, List<RequirementDefinition>> instancesRequirements = new HashMap<>();
1099
1100             Map<String, ComponentInstance> instancesMap = new HashMap<>();
1101             for (ComponentInstance currInstance : component.getComponentInstances()) {
1102                 instancesMap.put(currInstance.getUniqueId(), currInstance);
1103             }
1104             for (Map.Entry<String, MapListRequirementDataDefinition> entry : topologyTemplate.getCalculatedRequirements().entrySet()) {
1105
1106                 String instanceId = entry.getKey();
1107                 // Requirements of instance organized by capability
1108                 Map<String, ListRequirementDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1109
1110                 if(capsMapList != null) {
1111                     for (Entry<String, ListRequirementDataDefinition> entryTypeList : capsMapList.entrySet()) {
1112                         String capabilityType = entryTypeList.getKey();
1113                                         List<RequirementDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(RequirementDefinition::new).collect(Collectors.toList());
1114                         if (instancesRequirements.containsKey(capabilityType)) {
1115                             instancesRequirements.get(capabilityType).addAll(caps);
1116                         } else {
1117                             instancesRequirements.put(capabilityType, caps);
1118                         }
1119                         if (MapUtils.isEmpty(instancesMap.get(instanceId).getRequirements())) {
1120                             instancesMap.get(instanceId).setRequirements(new HashMap<>());
1121                         }
1122                         instancesMap.get(instanceId).getRequirements().put(capabilityType, new ArrayList<>(caps));
1123                     }
1124                 }
1125             }
1126             component.setRequirements(instancesRequirements);
1127         }
1128     }
1129
1130     private static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) {
1131         Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1132
1133         if (topologyTemplate.getCalculatedCapabilities() != null) {
1134             // capabilities of component organized by type
1135             Map<String, List<CapabilityDefinition>> instancesCapabilities = new HashMap<>();
1136
1137             Map<String, ComponentInstance> instancesMap = new HashMap<>();
1138             for (ComponentInstance currInstance : component.getComponentInstances()) {
1139                 instancesMap.put(currInstance.getUniqueId(), currInstance);
1140             }
1141             for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1142
1143                 String instanceId = entry.getKey();
1144                 // capabilities of instance organized by type
1145                 Map<String, ListCapabilityDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1146
1147                 if(capsMapList != null) {
1148                     for (Entry<String, ListCapabilityDataDefinition> entryTypeList : capsMapList.entrySet()) {
1149                         String capabilityType = entryTypeList.getKey();
1150                         List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList());
1151                         if (instancesCapabilities.containsKey(capabilityType)) {
1152                             instancesCapabilities.get(capabilityType).addAll(caps);
1153                         } else {
1154                             instancesCapabilities.put(capabilityType, caps);
1155                         }
1156                         ComponentInstance instance = instancesMap.get(instanceId);
1157                         if (instance == null) {
1158                             log.error("instance is null for id {} entry {}", instanceId, entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME));
1159                         } else {
1160                             if (MapUtils.isEmpty(instance.getCapabilities())) {
1161                                 instance.setCapabilities(new HashMap<>());
1162                             }
1163                             instance.getCapabilities().put(capabilityType, new ArrayList<>(caps));
1164                         }
1165                     }
1166                 }
1167             }
1168             component.setCapabilities(instancesCapabilities);
1169         }
1170     }
1171
1172         private static void setCapabilitiesToComponentAndGroups(TopologyTemplate topologyTemplate, Component component) {
1173
1174                 Map<String, MapCapabilityProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1175
1176                 if (capabilitiesAndGroupsExist(topologyTemplate, component)) {
1177                         Map<String, GroupDefinition> groupsMap = component.getGroups().stream().collect(Collectors.toMap(GroupDefinition::getUniqueId,Function.identity()));
1178
1179                         for (Map.Entry<String, MapListCapabilityDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1180                                 findSetCapabilitiesToComponentAndGroup(calculatedCapProperties, component, groupsMap, entry);
1181                         }
1182                 }
1183         }
1184
1185         private static boolean capabilitiesAndGroupsExist(TopologyTemplate topologyTemplate, Component component) {
1186                 return MapUtils.isNotEmpty(topologyTemplate.getCalculatedCapabilities()) && CollectionUtils.isNotEmpty(component.getGroups());
1187         }
1188
1189         private static void findSetCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component, Map<String, GroupDefinition> groupsMap, Map.Entry<String, MapListCapabilityDataDefinition> entry) {
1190
1191                 String uniqueId = entry.getKey();
1192                 if(groupsMap.containsKey(uniqueId)){
1193                         setCapabilitiesToComponentAndGroup(calculatedCapProperties, component, entry, groupsMap.get(uniqueId));
1194                 } else {
1195                         log.warn("The group with uniqueId {} was not found", uniqueId);
1196                 }
1197         }
1198
1199         private static void setCapabilitiesToComponentAndGroup(Map<String, MapCapabilityProperty> calculatedCapProperties, Component component, Map.Entry<String, MapListCapabilityDataDefinition> entry, GroupDefinition group) {
1200
1201                 for (Entry<String, ListCapabilityDataDefinition> entryTypeList : entry.getValue().getMapToscaDataDefinition().entrySet()) {
1202                         String capabilityType = entryTypeList.getKey();
1203                         List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, group.getUniqueId(), calculatedCapProperties)).collect(Collectors.toList());
1204                         if (component.getCapabilities().containsKey(capabilityType)) {
1205                                 component.getCapabilities().get(capabilityType).addAll(caps);
1206                         } else {
1207                                 component.getCapabilities().put(capabilityType, caps);
1208                         }
1209                         group.getCapabilities().put(capabilityType, Lists.newArrayList(caps));
1210                 }
1211         }
1212
1213         private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String ownerId, Map<String, MapCapabilityProperty> calculatedCapProperties) {
1214         CapabilityDefinition capability = new CapabilityDefinition(cap);
1215         if (calculatedCapProperties != null) {
1216                         MapCapabilityProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(ownerId);
1217             if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) {
1218                 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition();
1219                                 toscaCapPropMap.forEach(( keyPath,  capProp)-> findConvertSetProperties(cap, ownerId, capability, keyPath, capProp));
1220                         }
1221                 }
1222                 return capability;
1223         }
1224
1225         private static void findConvertSetProperties(CapabilityDataDefinition cap, String primaryPathKey, CapabilityDefinition capability, String path, MapPropertiesDataDefinition capProp) {
1226                 // format key of capability properties :
1227                 // VF instance in service : instanceId#ownerId#type#capName
1228                 // VFC instance in VF : instanceId#type#capName -> instanceId=ownerId
1229                 // Group in service : groupName#ownerId#type#capName
1230                 // Group in VF : groupName#type#capName -> groupName=ownerId
1231                 String[] result = path.split(CAP_PROP_DELIM);
1232                 if (result.length < 4) {
1233                         log.debug("wrong key format for capabilty, key {}", capProp);
1234                         return;
1235                 }
1236                 if (relatedPropertiesExist(cap, primaryPathKey, capProp, result)) {
1237                         capability.setProperties(capProp.getMapToscaDataDefinition().values().stream().map(ComponentInstanceProperty::new).collect(Collectors.toList()));
1238                 }
1239         }
1240
1241         private static boolean relatedPropertiesExist(CapabilityDataDefinition cap, String primaryPathKey,      MapPropertiesDataDefinition capProp, String[] result) {
1242                 return capProp != null && MapUtils.isNotEmpty(capProp.getMapToscaDataDefinition()) && areRelatedProperties(cap, primaryPathKey, result);
1243         }
1244
1245         private static boolean areRelatedProperties(CapabilityDataDefinition cap, String primaryPathKey, String[] result) {
1246                 int primaryKeyIndex = 0;
1247                 int ownerIndex = 1;
1248                 int typeIndex = result.length - 2;
1249                 int nameIndex = result.length - 1;
1250                 return result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex]) && primaryPathKey.equals(result[primaryKeyIndex]);
1251     }
1252
1253     private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1254
1255         Map<String, ComponentInstanceDataDefinition> componentInstances = new HashMap<>();
1256         ComponentInstanceDataDefinition convertedInstance;
1257         if (component.getComponentInstances() != null) {
1258             for (ComponentInstance instance : component.getComponentInstances()) {
1259                 convertedInstance = new ComponentInstanceDataDefinition(instance);
1260                 if (instance.getGroupInstances() != null) {
1261                     MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition();
1262
1263                                         groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(GroupInstanceDataDefinition::new).collect(Collectors.toMap(GroupInstanceDataDefinition::getName, Function.identity())));
1264                     if (topologyTemplate.getInstGroups() == null) {
1265                         topologyTemplate.setInstGroups(new HashMap<>());
1266                     }
1267                     topologyTemplate.getInstGroups().put(instance.getUniqueId(), groupsMap);
1268                 }
1269                 componentInstances.put(instance.getUniqueId(), convertedInstance);
1270             }
1271         }
1272         topologyTemplate.setComponentInstances(componentInstances);
1273
1274     }
1275
1276     private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1277
1278         if (component.getComponentInstancesInputs() != null) {
1279             topologyTemplate.setInstInputs(new HashMap<>());
1280             MapPropertiesDataDefinition inputsMap;
1281             for (Entry<String, List<ComponentInstanceInput>> entry : component.getComponentInstancesInputs().entrySet()) {
1282                 inputsMap = new MapPropertiesDataDefinition();
1283
1284                                 inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
1285
1286                 topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap);
1287             }
1288         }
1289     }
1290
1291     private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1292
1293         if (component.getComponentInstancesProperties() != null) {
1294             topologyTemplate.setInstProperties(new HashMap<>());
1295             MapPropertiesDataDefinition propertiesMap;
1296             for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesProperties().entrySet()) {
1297                 propertiesMap = new MapPropertiesDataDefinition();
1298
1299                                 propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
1300
1301                 topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap);
1302             }
1303         }
1304     }
1305
1306     private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1307
1308         List<ComponentInstance> componentInstances = component.getComponentInstances();
1309         if (componentInstances != null) {
1310             topologyTemplate.setInstanceArtifacts(new HashMap<>());
1311             topologyTemplate.setInstDeploymentArtifacts(new HashMap<>());
1312
1313             for (ComponentInstance ci : componentInstances) {
1314                 Map<String, ArtifactDefinition> artifacts = ci.getArtifacts();
1315                 if (artifacts != null) {
1316                                         Map<String, ArtifactDataDefinition> mapToscaDataDefinitionArtifact = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1317                     MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact);
1318                     topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact);
1319                 }
1320
1321                 Map<String, ArtifactDefinition> deplArtifacts = ci.getDeploymentArtifacts();
1322                 if (deplArtifacts != null) {
1323                                         Map<String, ArtifactDataDefinition> mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
1324                     MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact);
1325                     topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact);
1326                 }
1327             }
1328         }
1329     }
1330
1331     private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1332
1333         if (component.getComponentInstancesAttributes() != null) {
1334             topologyTemplate.setInstAttributes(new HashMap<>());
1335             MapPropertiesDataDefinition attributesMap;
1336             for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesAttributes().entrySet()) {
1337                 attributesMap = new MapPropertiesDataDefinition();
1338
1339                                 attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity())));
1340
1341                 topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap);
1342             }
1343         }
1344     }
1345
1346     public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) {
1347         ComponentMetadataData metadata = null;
1348         switch (vertex.getType()) {
1349         case SERVICE:
1350             metadata = new ServiceMetadataData(vertex.getMetadataJson());
1351             break;
1352         case RESOURCE:
1353             metadata = new ResourceMetadataData(vertex.getMetadataJson());
1354             break;
1355         case PRODUCT:
1356             metadata = new ProductMetadataData(vertex.getMetadataJson());
1357             break;
1358         default:
1359             break;
1360         }
1361         if (metadata != null) {
1362             metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId());
1363             metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
1364             metadata.getMetadataDataDefinition().setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID));
1365             metadata.getMetadataDataDefinition().setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE));
1366         }
1367         return metadata;
1368     }
1369
1370     public static List<GroupDefinition> convertToGroupDefinitions(Map<String, GroupDataDefinition> groups) {
1371
1372         List<GroupDefinition> groupDefinitions = null;
1373         if (MapUtils.isNotEmpty(groups)) {
1374                         groupDefinitions = groups.values().stream().map(GroupDefinition::new).collect(Collectors.toList());
1375         }
1376         return groupDefinitions;
1377         }
1378
1379         public static Map<String, MapCapabilityProperty> extractCapabilityProperteisFromInstances(List<ComponentInstance> instances, boolean fromCsar) {
1380                 return instances
1381                                 .stream()
1382                                 .collect(Collectors.toMap(ComponentInstanceDataDefinition::getUniqueId,
1383                                                 ci -> convertToMapOfMapCapabiltyProperties(ci.getCapabilities(), ci.getUniqueId(), fromCsar)));
1384         }
1385
1386         public static Map<String, MapCapabilityProperty> extractCapabilityPropertiesFromGroups(List<GroupDefinition> groups, boolean fromCsar) {
1387                 if(CollectionUtils.isNotEmpty(groups))
1388                         return groups
1389                                 .stream()
1390                                 .collect(Collectors.toMap(GroupDefinition::getUniqueId,
1391                                                 g -> convertToMapOfMapCapabiltyProperties(g.getCapabilities(), g.getUniqueId(), fromCsar)));
1392                 return Maps.newHashMap();
1393         }
1394
1395         public static Map<String, MapListCapabilityDataDefinition> extractCapabilitiesFromGroups(final List<GroupDefinition> groupDefinitions) {
1396                 Map<String, MapListCapabilityDataDefinition> calculatedCapabilities = Maps.newHashMap();
1397                 for(GroupDefinition groupDefinition :groupDefinitions){
1398                         calculatedCapabilities.put(groupDefinition.getUniqueId(), new MapListCapabilityDataDefinition(buildMapOfListsOfCapabilities(groupDefinition)));
1399                 }
1400                 return calculatedCapabilities;
1401         }
1402
1403         public static Map<String, ListCapabilityDataDefinition> buildMapOfListsOfCapabilities(GroupDefinition groupDefinition) {
1404                 return groupDefinition.getCapabilities().entrySet()
1405                                 .stream()
1406                                 .collect(Collectors.toMap(Map.Entry::getKey, e-> new ListCapabilityDataDefinition(e.getValue()
1407                                                 .stream()
1408                                                 .map(CapabilityDataDefinition::new)
1409                                                 .collect(Collectors.toList()))));
1410     }
1411
1412 }