catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/ModelConverter.java

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