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