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

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