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

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