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