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