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