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