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