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

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