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