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