catalog-model/src/main/java/org/openecomp/sdc/be/model/jsonjanusgraph/utils/ModelConverter.java

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