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