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

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