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