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