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