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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.model.jsontitan.utils;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Map.Entry;
  28 import java.util.Optional;
  29 import java.util.function.BiConsumer;
  30 import java.util.function.Function;
  31 import java.util.stream.Collectors;
  32
  33 import org.apache.commons.collections.CollectionUtils;
  34 import org.apache.commons.collections.MapUtils;
  35 import org.apache.commons.lang3.StringUtils;
  36 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  37 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  38 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
  39 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  40 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  41 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
  42 import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
  43 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  44 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
  45 import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
  46 import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
  47 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
  48 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
  49 import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
  50 import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty;
  51 import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition;
  52 import org.openecomp.sdc.be.datatypes.elements.MapListCapabiltyDataDefinition;
  53 import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
  54 import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
  55 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
  56 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  57 import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
  58 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  59 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  60 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  61 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  62 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  63 import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
  64 import org.openecomp.sdc.be.model.ArtifactDefinition;
  65 import org.openecomp.sdc.be.model.CapabilityDefinition;
  66 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  67 import org.openecomp.sdc.be.model.Component;
  68 import org.openecomp.sdc.be.model.ComponentInstance;
  69 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  70 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  71 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  72 import org.openecomp.sdc.be.model.GroupDefinition;
  73 import org.openecomp.sdc.be.model.GroupInstance;
  74 import org.openecomp.sdc.be.model.InputDefinition;
  75 import org.openecomp.sdc.be.model.InterfaceDefinition;
  76 import org.openecomp.sdc.be.model.PolicyDefinition;
  77 import org.openecomp.sdc.be.model.PropertyDefinition;
  78 import org.openecomp.sdc.be.model.RelationshipImpl;
  79 import org.openecomp.sdc.be.model.RelationshipInfo;
  80 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  81 import org.openecomp.sdc.be.model.RequirementDefinition;
  82 import org.openecomp.sdc.be.model.Resource;
  83 import org.openecomp.sdc.be.model.Service;
  84 import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType;
  85 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
  86 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
  87 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
  88 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
  89 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  90 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
  91 import org.openecomp.sdc.be.resources.data.ProductMetadataData;
  92 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
  93 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
  94 import org.slf4j.Logger;
  95 import org.slf4j.LoggerFactory;
  96
  97 public class ModelConverter {
  98         public static final String CAP_PROP_DELIM = "#";
  99         private static Logger log = LoggerFactory.getLogger(ModelConverter.class.getName());
 100
 101         @SuppressWarnings("unchecked")
 102         public static <T extends ToscaElement> T convertToToscaElement(Component component) {
 103                 if (isAtomicComponent(component)) {
 104                         return (T) convertToNodeType(component);
 105                 }
 106                 return (T) convertToTopologyTemplate(component);
 107         }
 108
 109         @SuppressWarnings("unchecked")
 110         public static <T extends Component> T convertFromToscaElement(ToscaElement toscaElement) {
 111                 switch (toscaElement.getComponentType()) {
 112                 case RESOURCE:
 113                         return (T) convertToResource(toscaElement);
 114                 case SERVICE:
 115                 case PRODUCT:
 116                         return (T) convertToService(toscaElement);
 117                 default:
 118                         return null;
 119                 }
 120         }
 121
 122         public static boolean isAtomicComponent(Component component) {
 123                 ComponentTypeEnum componentType = component.getComponentType();
 124                 if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
 125                         return false;
 126                 }
 127                 Resource resource = (Resource) component;
 128                 ResourceTypeEnum resType = resource.getResourceType();
 129                 return isAtomicComponent(resType);
 130         }
 131
 132         public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
 133                 if (resourceType == null) {
 134                         return false;
 135                 }
 136                 return resourceType.isAtomicType();
 137         }
 138
 139         // **********************************************************
 140         public static VertexTypeEnum getVertexType(Component component) {
 141                 VertexTypeEnum vertexType;
 142                 if (isAtomicComponent(component)) {
 143                         vertexType = VertexTypeEnum.NODE_TYPE;
 144                 } else {
 145                         vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
 146                 }
 147                 return vertexType;
 148         }
 149
 150         public static VertexTypeEnum getVertexType(String resourceTypeName) {
 151                 VertexTypeEnum vertexType = null;
 152                 ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName);
 153                 if (isAtomicComponent(resourceType)) {
 154                         vertexType = VertexTypeEnum.NODE_TYPE;
 155                 } else {
 156                         vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
 157                 }
 158                 return vertexType;
 159         }
 160
 161
 162
 163         private static Service convertToService(ToscaElement toscaElement) {
 164                 Service service = new Service();
 165                 convertComponentFields(service, toscaElement);
 166
 167                 convertServiceSpecificFields(toscaElement, service);
 168
 169                 TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
 170
 171                 convertComponentInstances(topologyTemplate, service);
 172
 173                 convertInputs(topologyTemplate, service);
 174
 175                 convertPolicies(topologyTemplate, service);
 176
 177                 convertGroups(topologyTemplate, service);
 178
 179                 convertPolicies(topologyTemplate, service);
 180
 181                 convertGroups(topologyTemplate, service);
 182
 183                 convertPolicies(topologyTemplate, service);
 184
 185                 convertRelations(topologyTemplate, service);
 186
 187                 convertArtifacts(topologyTemplate, service);
 188
 189                 convertServiceApiArtifacts(topologyTemplate, service);
 190
 191                 convertServicePaths(topologyTemplate, service);
 192
 193                 return service;
 194         }
 195
 196         private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) {
 197                 service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE));
 198                 service.setDistributionStatus(DistributionStatusEnum.findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
 199                 service.setEcompGeneratedNaming((Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
 200                 service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, StringUtils.EMPTY));
 201                 service.setEnvironmentContext((String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT));
 202         }
 203
 204         private static Resource convertToResource(ToscaElement toscaElement) {
 205                 Resource resource = new Resource();
 206                 convertComponentFields(resource, toscaElement);
 207
 208                 resource.setResourceType(toscaElement.getResourceType());
 209                 if (toscaElement.getToscaType() == ToscaElementTypeEnum.NodeType) {
 210                         NodeType nodeType = (NodeType) toscaElement;
 211                         resource.setDerivedFrom(nodeType.getDerivedFrom());
 212                         resource.setDerivedList(nodeType.getDerivedList());
 213                         resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
 214                         convertAttributes(nodeType, resource);
 215                         convertCapabilities(nodeType, resource);
 216                         convertRequirements(nodeType, resource);
 217                         convertInterfaces(nodeType, resource);
 218
 219                 } else {
 220                         TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
 221                         if (resource.getResourceType() == ResourceTypeEnum.VF) {
 222                                 resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
 223                                 resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
 224                                 resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
 225
 226                         }
 227                         convertComponentInstances(topologyTemplate, resource);
 228                         convertRelations(topologyTemplate, resource);
 229                         convertInputs(topologyTemplate, resource);
 230                         convertGroups(topologyTemplate, resource);
 231                         convertPolicies(topologyTemplate, resource);
 232                 }
 233                 convertArtifacts(toscaElement, resource);
 234                 convertAdditionalInformation(toscaElement, resource);
 235
 236                 return resource;
 237         }
 238
 239         private static void convertAttributes(NodeType nodeType, Resource resource) {
 240                 Map<String, PropertyDataDefinition> attributes = nodeType.getAttributes();
 241                 if (attributes != null) {
 242                         List<PropertyDefinition> attrs = attributes.values().stream().map(dataDef -> ModelConverter.fromDataDefinition(resource.getUniqueId(), dataDef)).collect(Collectors.toList());
 243                         resource.setAttributes(attrs);
 244                 }
 245         }
 246
 247         private static PropertyDefinition fromDataDefinition(String resourceId, PropertyDataDefinition dataDefinition) {
 248                 PropertyDefinition attributeDefinition = new PropertyDefinition(dataDefinition);
 249                 attributeDefinition.setParentUniqueId(resourceId);
 250                 return attributeDefinition;
 251         }
 252
 253         private static void convertInterfaces(NodeType nodeType, Resource resource) {
 254                 Map<String, InterfaceDataDefinition> interfaceArtifacts = nodeType.getInterfaceArtifacts();
 255                 if (interfaceArtifacts != null) {
 256                         Map<String, InterfaceDefinition> interfaces = interfaceArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue())));
 257                         resource.setInterfaces(interfaces);
 258                 }
 259         }
 260
 261         /**
 262          * Converts component instances of topology template to component instances of resource
 263          *
 264          * @param topologyTemplate
 265          * @param component
 266          */
 267         public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) {
 268
 269                 if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) {
 270
 271                         setComponentInstancesAttributesToComponent(topologyTemplate, component);
 272
 273                         setComponentInstancesPropertiesToComponent(topologyTemplate, component);
 274
 275                         setComponentInstancesInputsToComponent(topologyTemplate, component);
 276
 277                         setComponentInstancesToComponent(topologyTemplate, component);
 278
 279                         setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component);
 280
 281                         setComponentInstancesRequirementsToComponent(topologyTemplate, component);
 282
 283                         setComponentInstancesArtifactsToComponent(topologyTemplate, component);
 284
 285                 }
 286         }
 287
 288         private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) {
 289                 Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts();
 290                 Map<String, MapArtifactDataDefinition> instanceArtifacts = topologyTemplate.getInstanceArtifacts();
 291
 292                 List<ComponentInstance> instances = component.getComponentInstances();
 293                 if (instDeploymentArtifacts != null && instances != null) {
 294                         instDeploymentArtifacts.entrySet().forEach(e -> {
 295                                 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
 296                                 if (ci.isPresent()) {
 297                                         Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
 298                                         Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
 299
 300                                         ci.get().setDeploymentArtifacts(deplArt);
 301                                 }
 302                         });
 303                 }
 304                 if (instanceArtifacts != null && instances != null) {
 305                         instanceArtifacts.entrySet().forEach(e -> {
 306                                 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
 307                                 if (ci.isPresent()) {
 308                                         Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
 309                                         Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
 310
 311                                         ci.get().setArtifacts(deplArt);
 312                                 }
 313                         });
 314                 }
 315
 316         }
 317
 318         public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) {
 319
 320                 if (!CollectionUtils.isEmpty(component.getComponentInstances())) {
 321
 322                         setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate);
 323
 324                         setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate);
 325
 326                         setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate);
 327
 328                         setComponentInstancesToTopologyTemplate(component, topologyTemplate);
 329
 330                         setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate);
 331                 }
 332         }
 333
 334         public static void convertRelations(TopologyTemplate topologyTemplate, Component component) {
 335                 Map<String, RelationshipInstDataDefinition> relations = topologyTemplate.getRelations();
 336                 List<RequirementCapabilityRelDef> componentRelations;
 337                 if (relations != null && !relations.isEmpty()) {
 338                         componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList());
 339
 340                 } else {
 341                         componentRelations = new ArrayList<>();
 342                 }
 343                 component.setComponentInstancesRelations(componentRelations);
 344
 345         }
 346
 347         public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) {
 348                 RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
 349                 requirementCapabilityRelDef.setFromNode(relation.getFromId());
 350                 requirementCapabilityRelDef.setToNode(relation.getToId());
 351                 RelationshipInfo relationshipPair = new RelationshipInfo();
 352                 relationshipPair.setId(relation.getUniqueId());
 353                 relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
 354                 relationshipPair.setCapabilityUid(relation.getCapabilityId());
 355                 relationshipPair.setCapability(relation.getCapability());
 356                 relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
 357                 relationshipPair.setRequirementUid(relation.getRequirementId());
 358                 relationshipPair.setRequirement(relation.getRequirement());
 359                 RelationshipImpl relationship = new RelationshipImpl();
 360                 relationship.setType(relation.getType());
 361                 relationshipPair.setRelationships(relationship);
 362                 CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship();
 363                 rel.setRelation(relationshipPair);
 364                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 365                 relationships.add(rel);
 366                 requirementCapabilityRelDef.setRelationships(relationships);
 367                 return requirementCapabilityRelDef;
 368         }
 369
 370         public static List<RelationshipInstDataDefinition> convertRelationToToscaRelation(RequirementCapabilityRelDef relation) {
 371
 372                 List<RelationshipInstDataDefinition> relationsList = new ArrayList<>();
 373
 374                 List<CapabilityRequirementRelationship> relationship = relation.getRelationships();
 375                 relationship.forEach(p -> {
 376                         RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition();
 377                         requirementCapabilityRelDef.setFromId(relation.getFromNode());
 378                         requirementCapabilityRelDef.setToId(relation.getToNode());
 379                         requirementCapabilityRelDef.setUniqueId(p.getRelation().getId());
 380                         requirementCapabilityRelDef.setCapabilityOwnerId(p.getRelation().getCapabilityOwnerId());
 381                         requirementCapabilityRelDef.setCapabilityId(p.getRelation().getCapabilityUid());
 382                         requirementCapabilityRelDef.setRequirementOwnerId(p.getRelation().getRequirementOwnerId());
 383                         requirementCapabilityRelDef.setRequirementId(p.getRelation().getRequirementUid());
 384                         requirementCapabilityRelDef.setRequirement(p.getRelation().getRequirement());
 385                         requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType());
 386                         requirementCapabilityRelDef.setCapability(p.getRelation().getCapability());
 387
 388                         relationsList.add(requirementCapabilityRelDef);
 389                 });
 390
 391                 return relationsList;
 392         }
 393
 394         private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) {
 395
 396                 if (component.getCapabilities() != null && component.getComponentInstances() != null) {
 397                         topologyTemplate.setCalculatedCapabilities(new HashMap<>());
 398                         topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
 399                         for (ComponentInstance instance : component.getComponentInstances()) {
 400                                 Map<String, List<CapabilityDefinition>> instCapabilities = instance.getCapabilities();
 401                                 if (MapUtils.isNotEmpty(instCapabilities)) {
 402                                         if (topologyTemplate.getCalculatedCapabilities() == null) {
 403                                                 topologyTemplate.setCalculatedCapabilities(new HashMap<>());
 404                                         }
 405                                         topologyTemplate.getCalculatedCapabilities().put(instance.getUniqueId(), convertToMapListCapabiltyDataDefinition(instCapabilities));
 406                                         if (topologyTemplate.getCalculatedCapabilitiesProperties() == null) {
 407                                                 topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
 408                                         }
 409                                         topologyTemplate.getCalculatedCapabilitiesProperties().put(instance.getUniqueId(), convertToMapOfMapCapabiltyProperties(instCapabilities, instance.getUniqueId()));
 410                                 }
 411                         }
 412                 }
 413         }
 414
 415         public static MapCapabiltyProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities, String instanceId) {
 416                 return convertToMapOfMapCapabiltyProperties(instCapabilities, instanceId, false);
 417         }
 418
 419         public static MapCapabiltyProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities, String instanceId, boolean fromCsar) {
 420
 421                 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
 422
 423                 instCapabilities.forEach(new BiConsumer<String, List<CapabilityDefinition>>() {
 424                         @Override
 425                         public void accept(String s, List<CapabilityDefinition> caps) {
 426
 427                                 if (caps != null && !caps.isEmpty()) {
 428
 429                                         MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
 430
 431                                         for (CapabilityDefinition cap : caps) {
 432                                                 List<ComponentInstanceProperty> capPrps = cap.getProperties();
 433                                                 if (capPrps != null) {
 434
 435                                                         for (ComponentInstanceProperty cip : capPrps) {
 436                                                                 dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
 437                                                         }
 438                                                         // format key of capability properties :
 439                                                         // VF instance in service : instanceId#ownerId#type#capName
 440                                                         // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId
 441
 442                                                         StringBuffer sb = new StringBuffer(instanceId);
 443                                                         sb.append(CAP_PROP_DELIM);
 444                                                         if (fromCsar) {
 445                                                                 sb.append(instanceId);
 446                                                         } else {
 447                                                                 sb.append(cap.getOwnerId());
 448                                                         }
 449                                                         sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
 450                                                         toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate));
 451                                                 }
 452                                         }
 453
 454                                 }
 455
 456                         }
 457                 });
 458                 return new MapCapabiltyProperty(toscaCapPropMap);
 459         }
 460
 461         private static MapListCapabiltyDataDefinition convertToMapListCapabiltyDataDefinition(Map<String, List<CapabilityDefinition>> instCapabilities) {
 462
 463                 Map<String, ListCapabilityDataDefinition> mapToscaDataDefinition = new HashMap<>();
 464                 for (Entry<String, List<CapabilityDefinition>> instCapability : instCapabilities.entrySet()) {
 465                         mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(iCap -> new CapabilityDataDefinition(iCap)).collect(Collectors.toList())));
 466                 }
 467
 468                 return new MapListCapabiltyDataDefinition(mapToscaDataDefinition);
 469         }
 470
 471         private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) {
 472
 473                 if (component.getRequirements() != null && component.getComponentInstances() != null) {
 474                         topologyTemplate.setCalculatedRequirements(new HashMap<>());
 475                         for (ComponentInstance instance : component.getComponentInstances()) {
 476                                 Map<String, List<RequirementDefinition>> instRequirements = instance.getRequirements();
 477                                 if (MapUtils.isNotEmpty(instRequirements)) {
 478                                         if (topologyTemplate.getCalculatedRequirements() == null) {
 479                                                 topologyTemplate.setCalculatedRequirements(new HashMap<>());
 480                                         }
 481                                         topologyTemplate.getCalculatedRequirements().put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements));
 482                                 }
 483                         }
 484                 }
 485         }
 486
 487         private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(Map<String, List<RequirementDefinition>> instRequirements) {
 488
 489                 Map<String, ListRequirementDataDefinition> mapToscaDataDefinition = new HashMap<>();
 490                 for (Entry<String, List<RequirementDefinition>> instRequirement : instRequirements.entrySet()) {
 491                         mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(instRequirement.getValue().stream().map(iCap -> new RequirementDataDefinition(iCap)).collect(Collectors.toList())));
 492                 }
 493
 494                 return new MapListRequirementDataDefinition(mapToscaDataDefinition);
 495         }
 496
 497         @SuppressWarnings("unchecked")
 498         private static void convertComponentFields(Component component, ToscaElement toscaElement) {
 499                 component.setName(toscaElement.getName());
 500                 component.setAllVersions(toscaElement.getAllVersions());
 501                 component.setCategories(toscaElement.getCategories());
 502                 component.setComponentType(toscaElement.getComponentType());
 503                 component.setCreationDate(toscaElement.getCreationDate());
 504                 component.setCreatorUserId(toscaElement.getCreatorUserId());
 505                 component.setCreatorFullName(toscaElement.getCreatorFullName());
 506                 component.setLastUpdateDate(toscaElement.getLastUpdateDate());
 507                 component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName());
 508                 component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId());
 509                 component.setNormalizedName(toscaElement.getNormalizedName());
 510
 511                 component.setLifecycleState(toscaElement.getLifecycleState());
 512                 component.setVersion(toscaElement.getVersion());
 513                 component.setHighestVersion(toscaElement.isHighestVersion());
 514                 component.setUniqueId(toscaElement.getUniqueId());
 515                 component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME));
 516                 component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType());
 517                 component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion());
 518
 519                 if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
 520                         Resource resource = (Resource) component;
 521                         resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
 522                         resource.setToscaResourceName((String) toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
 523                         resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME));
 524                         resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE));
 525                         // field isn't mandatory , but shouldn't be null(should be an empty string instead)
 526                         if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null){
 527                                 resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER));
 528                         } else {
 529                                 resource.setResourceVendorModelNumber("");
 530                         }
 531                 } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
 532                         Service service = (Service) component;
 533                         if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null){
 534                                 service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE));
 535                         } else {
 536                                 service.setServiceType("");
 537                         }
 538                         if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null){
 539                                 service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE));
 540                         } else {
 541                                 service.setServiceRole("");
 542                         }
 543                 }
 544                 component.setConformanceLevel((String) toscaElement.getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL));
 545                 component.setIcon((String) toscaElement.getMetadataValue(JsonPresentationFields.ICON));
 546                 component.setDescription((String) toscaElement.getMetadataValue(JsonPresentationFields.DESCRIPTION));
 547                 component.setTags((List<String>) toscaElement.getMetadataValue(JsonPresentationFields.TAGS));
 548                 component.setInvariantUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID));
 549                 component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID));
 550                 component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID));
 551                 component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED));
 552
 553                 Map<String, PropertyDataDefinition> properties = toscaElement.getProperties();
 554                 if (properties != null && !properties.isEmpty()) {
 555                         List<PropertyDefinition> propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList());
 556                         ((Resource) component).setProperties(propertiesMap);
 557                 }
 558
 559                 component.setToscaType(toscaElement.getToscaType().getValue());
 560         }
 561
 562         private static NodeType convertToNodeType(Component component) {
 563                 Resource resource = (Resource) component;
 564                 NodeType nodeType = new NodeType();
 565                 nodeType.setDerivedFrom(resource.getDerivedFrom());
 566                 nodeType.setDerivedList(resource.getDerivedList());
 567                 nodeType.setResourceType(resource.getResourceType());
 568                 // nodeType.setCapabiltiesProperties(capabiltiesProperties);
 569                 convertCommonToscaData(component, nodeType);
 570                 convertAdditionalInformation(component, nodeType);
 571                 convertArtifacts(resource, nodeType);
 572                 convertCapabilities(resource, nodeType);
 573                 convertRequirements(resource, nodeType);
 574                 convertAttributes(resource, nodeType);
 575                 convertProperties(resource, nodeType);
 576                 convertInterfaces(resource, nodeType);
 577                 return nodeType;
 578         }
 579
 580         private static void convertProperties(Resource resource, NodeType nodeType) {
 581                 List<PropertyDefinition> properties = resource.getProperties();
 582                 if (properties != null && !properties.isEmpty()) {
 583                         Map<String, PropertyDataDefinition> propertiesMap = properties.stream().collect(Collectors.toMap(x -> x.getName(), x -> new PropertyDataDefinition(x)));
 584                         nodeType.setProperties(propertiesMap);
 585                 }
 586         }
 587
 588         private static void convertInterfaces(Resource resource, NodeType nodeType) {
 589                 Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
 590                 if (interfaces != null) {
 591                         Map<String, InterfaceDataDefinition> interfaceArtifacts = interfaces.entrySet().stream().collect(Collectors.toMap(x -> x.getKey(), x -> new InterfaceDataDefinition(x.getValue())));
 592                         nodeType.setInterfaceArtifacts(interfaceArtifacts);
 593                 }
 594         }
 595
 596         private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) {
 597                 List<AdditionalInformationDefinition> additionalInformation = component.getAdditionalInformation();
 598                 if (additionalInformation != null) {
 599                         Map<String, AdditionalInfoParameterDataDefinition> addInfo = additionalInformation.stream().collect(Collectors.toMap(x -> x.getUniqueId(), x -> new AdditionalInfoParameterDataDefinition(x)));
 600                         toscaElement.setAdditionalInformation(addInfo);
 601                 }
 602         }
 603
 604         private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) {
 605                 Map<String, AdditionalInfoParameterDataDefinition> additionalInformation = toscaElement.getAdditionalInformation();
 606                 if (additionalInformation != null) {
 607                         List<AdditionalInformationDefinition> addInfo = additionalInformation.values().stream().map(e -> {
 608                                 return new AdditionalInformationDefinition(e);
 609                         }).collect(Collectors.toList());
 610                         resource.setAdditionalInformation(addInfo);
 611                 }
 612         }
 613
 614         private static void convertArtifacts(ToscaElement toscaElement, Component component) {
 615                 Map<String, ArtifactDataDefinition> artifacts = toscaElement.getArtifacts();
 616                 Map<String, ArtifactDefinition> copy;
 617                 if (artifacts != null) {
 618                         copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 619
 620                 } else {
 621                         copy = new HashMap<>();
 622                 }
 623                 component.setArtifacts(copy);
 624
 625                 Map<String, ArtifactDataDefinition> toscaArtifacts = toscaElement.getToscaArtifacts();
 626                 if (toscaArtifacts != null) {
 627                         copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 628
 629                 } else {
 630                         copy = new HashMap<>();
 631                 }
 632                 component.setToscaArtifacts(copy);
 633
 634                 Map<String, ArtifactDataDefinition> deploymentArtifacts = toscaElement.getDeploymentArtifacts();
 635                 if (deploymentArtifacts != null) {
 636                         copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 637
 638                 } else {
 639                         copy = new HashMap<>();
 640                 }
 641                 component.setDeploymentArtifacts(copy);
 642         }
 643
 644         private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) {
 645                 Map<String, ArtifactDataDefinition> serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts();
 646                 Map<String, ArtifactDefinition> copy;
 647                 if (serviceApiArtifacts != null) {
 648                         copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
 649
 650                 } else {
 651                         copy = new HashMap<>();
 652                 }
 653                 service.setServiceApiArtifacts(copy);
 654         }
 655         private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) {
 656                 Map<String, ForwardingPathDataDefinition> servicePaths = topologyTemplate.getForwardingPaths();
 657                 Map<String, ForwardingPathDataDefinition> copy;
 658                 if (servicePaths != null) {
 659                         copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
 660
 661                 } else {
 662                         copy = new HashMap<>();
 663                 }
 664                 service.setForwardingPaths(copy);
 665         }
 666
 667         private static void convertArtifacts(Component component, ToscaElement toscaElement) {
 668                 Map<String, ArtifactDefinition> artifacts = component.getArtifacts();
 669                 if (artifacts != null) {
 670                         Map<String, ArtifactDataDefinition> copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 671                         toscaElement.setArtifacts(copy);
 672                 }
 673
 674                 Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
 675                 if (toscaArtifacts != null) {
 676                         Map<String, ArtifactDataDefinition> copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 677                         toscaElement.setToscaArtifacts(copy);
 678                 }
 679
 680                 Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
 681                 if (deploymentArtifacts != null) {
 682                         Map<String, ArtifactDataDefinition> copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 683                         toscaElement.setDeploymentArtifacts(copy);
 684                 }
 685         }
 686
 687         private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) {
 688                 Map<String, ArtifactDefinition> serviceApiArtifacts = service.getServiceApiArtifacts();
 689                 if (serviceApiArtifacts != null) {
 690                         Map<String, ArtifactDataDefinition> copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
 691                         topologyTemplate.setServiceApiArtifacts(copy);
 692                 }
 693         }
 694
 695         private static void convertCapabilities(Component component, NodeType toscaElement) {
 696                 Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
 697
 698                 Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
 699                 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
 700
 701                 if (capabilities != null && !capabilities.isEmpty()) {
 702                         capabilities.forEach(new BiConsumer<String, List<CapabilityDefinition>>() {
 703                                 @Override
 704                                 public void accept(String s, List<CapabilityDefinition> caps) {
 705
 706                                         if (caps != null && !caps.isEmpty()) {
 707                                                 List<CapabilityDataDefinition> capList = caps.stream().map(o -> {
 708                                                         return new CapabilityDataDefinition(o);
 709                                                 }).collect(Collectors.toList());
 710
 711                                                 ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList);
 712                                                 toscaCapMap.put(s, listCapabilityDataDefinition);
 713
 714                                                 for (CapabilityDefinition cap : caps) {
 715                                                         List<ComponentInstanceProperty> capPrps = cap.getProperties();
 716                                                         if (capPrps != null && !capPrps.isEmpty()) {
 717
 718                                                                 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
 719                                                                 for (ComponentInstanceProperty cip : capPrps) {
 720                                                                         dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
 721                                                                 }
 722
 723                                                                 toscaCapPropMap.put(s + CAP_PROP_DELIM + cap.getName(), dataToCreate);
 724                                                         }
 725                                                 }
 726
 727                                         }
 728
 729                                 }
 730                         });
 731
 732                         toscaElement.setCapabilties(toscaCapMap);
 733                         toscaElement.setCapabiltiesProperties(toscaCapPropMap);
 734                 }
 735         }
 736
 737         private static void convertAttributes(Resource component, NodeType nodeType) {
 738                 List<PropertyDefinition> attributes = component.getAttributes();
 739                 if (attributes != null) {
 740                         Map<String, PropertyDataDefinition> attrsByName = attributes.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
 741                         nodeType.setAttributes(attrsByName);
 742                 }
 743         }
 744
 745         private static void convertRequirements(Resource component, NodeType nodeType) {
 746                 Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
 747
 748                 Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
 749
 750                 if (requirements != null && !requirements.isEmpty()) {
 751                         requirements.forEach(new BiConsumer<String, List<RequirementDefinition>>() {
 752                                 @Override
 753                                 public void accept(String s, List<RequirementDefinition> reqs) {
 754
 755                                         if (reqs != null && !reqs.isEmpty()) {
 756                                                 List<RequirementDataDefinition> reqList = reqs.stream().map(o -> {
 757                                                         return new RequirementDataDefinition(o);
 758                                                 }).collect(Collectors.toList());
 759
 760                                                 ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
 761                                                 toscaReqMap.put(s, listRequirementDataDefinition);
 762                                         }
 763                                 }
 764                         });
 765                         nodeType.setRequirements(toscaReqMap);
 766                 }
 767         }
 768
 769         private static void convertCapabilities(NodeType toscaElement, Component component) {
 770                 Map<String, ListCapabilityDataDefinition> toscaCapabilities = toscaElement.getCapabilties();
 771                 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = toscaElement.getCapabiltiesProperties();
 772
 773                 Map<String, List<CapabilityDefinition>> compCap = new HashMap<>();
 774                 if (toscaCapabilities == null || toscaCapabilities.isEmpty())
 775                         return;
 776                 toscaCapabilities.forEach(new BiConsumer<String, ListCapabilityDataDefinition>() {
 777                         @Override
 778                         public void accept(String s, ListCapabilityDataDefinition cap) {
 779
 780                                 if (cap != null) {
 781                                         List<CapabilityDataDefinition> capDataList = cap.getListToscaDataDefinition();
 782
 783                                         if (capDataList != null && !capDataList.isEmpty()) {
 784                                                 List<CapabilityDefinition> capList = capDataList.stream().map(o -> {
 785
 786                                                         return new CapabilityDefinition(o);
 787                                                 }).collect(Collectors.toList());
 788                                                 compCap.put(s, capList);
 789                                         }
 790                                 }
 791
 792                         }
 793                 });
 794                 if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) {
 795                         toscaCapPropMap.forEach(new BiConsumer<String, MapPropertiesDataDefinition>() {
 796                                 @Override
 797                                 public void accept(String s, MapPropertiesDataDefinition capProp) {
 798                                         String[] result = s.split(CAP_PROP_DELIM);
 799                                         if (capProp != null) {
 800                                                 Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
 801
 802                                                 if (capMap != null && !capMap.isEmpty()) {
 803                                                         // List<PropertyDataDefinition> list = map.values().stream().collect(Collectors.toList());
 804                                                         List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(o -> {
 805
 806                                                                 return new ComponentInstanceProperty(o);
 807                                                         }).collect(Collectors.toList());
 808
 809                                                         List<CapabilityDefinition> cap = compCap.get(result[0]);
 810                                                         Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
 811                                                         if (op.isPresent()) {
 812                                                                 op.get().setProperties(capPropsList);
 813                                                         }
 814                                                 }
 815
 816                                         }
 817
 818                                 }
 819                         });
 820                 }
 821
 822                 component.setCapabilities(compCap);
 823
 824         }
 825
 826         private static void convertGroups(TopologyTemplate toscaElement, Component component) {
 827                 Map<String, GroupDataDefinition> toscaGroups = toscaElement.getGroups();
 828                 List<GroupDefinition> groupDefinitions = null;
 829                 if (MapUtils.isNotEmpty(toscaGroups)) {
 830                         groupDefinitions = toscaGroups.values().stream().map(g -> new GroupDefinition(g)).collect(Collectors.toList());
 831                 }
 832                 component.setGroups(groupDefinitions);
 833         }
 834
 835         private static void convertPolicies(TopologyTemplate toscaElement, Component component) {
 836                 Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies();
 837                 Map<String, PolicyDefinition> policyDefinitions = null;
 838                 if (MapUtils.isNotEmpty(policies)) {
 839                         policyDefinitions = policies.values().stream().map(p -> new PolicyDefinition(p)).collect(Collectors.toMap(p->p.getUniqueId(), p->p));
 840                 }
 841                 component.setPolicies(policyDefinitions);
 842         }
 843
 844         private static void convertGroups(Component component, TopologyTemplate toscaElement) {
 845                 List<GroupDefinition> groupDefinitions = component.getGroups();
 846                 Map<String, GroupDataDefinition> groups = new HashMap<>();
 847
 848                 if (groupDefinitions != null && groups.isEmpty()) {
 849                         groups = groupDefinitions.stream().collect(Collectors.toMap(pr -> pr.getName(), pr -> new GroupDataDefinition(pr)));
 850                 }
 851                 toscaElement.setGroups(groups);
 852         }
 853
 854         private static void convertPolicies(Component component, TopologyTemplate toscaElement) {
 855                 Map<String, PolicyDefinition> policyDefinitions = component.getPolicies();
 856                 Map<String, PolicyDataDefinition> policies = new HashMap<>();
 857                 if (MapUtils.isNotEmpty(policyDefinitions)) {
 858                         policies = policyDefinitions.values().stream().collect((Collectors.toMap(p -> p.getUniqueId(), p -> new PolicyDataDefinition(p))));
 859                 }
 860                 toscaElement.setPolicies(policies);
 861         }
 862
 863         private static void convertRequirements(NodeType toscaElement, Component component) {
 864                 Map<String, ListRequirementDataDefinition> toscaRequirements = toscaElement.getRequirements();
 865
 866                 Map<String, List<RequirementDefinition>> compReqs = new HashMap<>();
 867                 if (toscaRequirements == null || toscaRequirements.isEmpty())
 868                         return;
 869                 toscaRequirements.forEach(new BiConsumer<String, ListRequirementDataDefinition>() {
 870                         @Override
 871                         public void accept(String s, ListRequirementDataDefinition req) {
 872
 873                                 if (req != null) {
 874                                         List<RequirementDataDefinition> reqDataList = req.getListToscaDataDefinition();
 875
 876                                         if (reqDataList != null && !reqDataList.isEmpty()) {
 877                                                 List<RequirementDefinition> reqList = reqDataList.stream().map(o -> {
 878
 879                                                         return new RequirementDefinition(o);
 880                                                 }).collect(Collectors.toList());
 881                                                 compReqs.put(s, reqList);
 882                                         }
 883                                 }
 884                         }
 885                 });
 886                 component.setRequirements(compReqs);
 887         }
 888
 889         private static TopologyTemplate convertToTopologyTemplate(Component component) {
 890                 TopologyTemplate topologyTemplate;
 891                 ComponentTypeEnum componentType = component.getComponentType();
 892                 topologyTemplate = new TopologyTemplate();
 893
 894                 if (componentType == ComponentTypeEnum.RESOURCE) {
 895                         Resource resource = (Resource) component;
 896                         topologyTemplate.setResourceType(resource.getResourceType());
 897                         topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
 898                         topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
 899                         topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
 900                 }
 901                 if (componentType == ComponentTypeEnum.SERVICE) {
 902                         convertServiceSpecificEntities((Service) component, topologyTemplate);
 903                 }
 904                 convertCommonToscaData(component, topologyTemplate);
 905                 convertArtifacts(component, topologyTemplate);
 906
 907                 convertAdditionalInformation(component, topologyTemplate);
 908                 convertComponentInstances(component, topologyTemplate);
 909
 910                 convertInputs(component, topologyTemplate);
 911                 convertCapabilities(component, topologyTemplate);
 912                 convertGroups(component, topologyTemplate);
 913                 convertPolicies(component, topologyTemplate);
 914                 convertRequirements(component, topologyTemplate);
 915                 convertRelationsToComposition(component, topologyTemplate);
 916
 917                 return topologyTemplate;
 918         }
 919
 920         private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) {
 921                 convertServiceMetaData(service, topologyTemplate);
 922                 convertServiceApiArtifacts(service, topologyTemplate);
 923                 convertServicePaths(service,topologyTemplate);
 924         }
 925
 926         private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) {
 927                 Map<String, ForwardingPathDataDefinition> servicePaths = service.getForwardingPaths();
 928                 if (servicePaths != null && !servicePaths.isEmpty()) {
 929                         Map<String, ForwardingPathDataDefinition> copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
 930                         topologyTemplate.setForwardingPaths(copy);
 931                 }
 932         }
 933
 934         private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
 935                 if (service.getDistributionStatus() != null) {
 936                         topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS, service.getDistributionStatus().name());
 937                 }
 938                 topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
 939                 topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, service.isEcompGeneratedNaming());
 940                 topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
 941                 topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext());
 942
 943         }
 944
 945         private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) {
 946                 List<RequirementCapabilityRelDef> componentInstancesRelations = component.getComponentInstancesRelations();
 947                 if (componentInstancesRelations != null) {
 948                         Map<String, CompositionDataDefinition> compositions = topologyTemplate.getCompositions();
 949                         if (compositions == null) {
 950                                 compositions = new HashMap<>();
 951                         }
 952                         CompositionDataDefinition compositionDataDefinition = compositions.get(JsonConstantKeysEnum.COMPOSITION.getValue());
 953                         if (compositionDataDefinition == null) {
 954                                 compositionDataDefinition = new CompositionDataDefinition();
 955                                 compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition);
 956                         }
 957
 958                         Map<String, RelationshipInstDataDefinition> relations = componentInstancesRelations.stream().flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null)
 959                                         .collect(Collectors.toMap(i -> i.getUniqueId(), i -> i));
 960                         compositionDataDefinition.setRelations(relations);
 961                 }
 962         }
 963
 964         private static void convertInputs(Component component, TopologyTemplate topologyTemplate) {
 965                 List<InputDefinition> inputsList = component.getInputs();
 966                 if (inputsList != null && !inputsList.isEmpty()) {
 967
 968                         Map<String, PropertyDataDefinition> inputsMap = inputsList.stream().map(i -> new PropertyDataDefinition(i)).collect(Collectors.toMap(i -> i.getName(), i -> i));
 969                         topologyTemplate.setInputs(inputsMap);
 970                 }
 971
 972         }
 973
 974         private static void convertInputs(TopologyTemplate topologyTemplate, Component component) {
 975                 Map<String, PropertyDataDefinition> inputsMap = topologyTemplate.getInputs();
 976                 if (inputsMap != null && !inputsMap.isEmpty()) {
 977                         List<InputDefinition> inputsList = inputsMap.values().stream().map(i -> new InputDefinition(i)).collect(Collectors.toList());
 978                         component.setInputs(inputsList);
 979                 }
 980
 981         }
 982
 983         private static void convertCommonToscaData(Component component, ToscaElement toscaElement) {
 984                 toscaElement.setUUID(component.getUUID());
 985                 toscaElement.setUniqueId(component.getUniqueId());
 986                 toscaElement.setSystemName(component.getSystemName());
 987                 toscaElement.setLifecycleState(component.getLifecycleState());
 988                 toscaElement.setComponentType(component.getComponentType());
 989                 toscaElement.setNormalizedName(component.getNormalizedName());
 990                 toscaElement.setMetadataValue(JsonPresentationFields.NAME, component.getName());
 991                 toscaElement.setCategories(component.getCategories());
 992                 toscaElement.setCreatorUserId(component.getCreatorUserId());
 993                 toscaElement.setCreationDate(component.getCreationDate());
 994                 toscaElement.setCreatorFullName(component.getCreatorFullName());
 995                 toscaElement.setHighestVersion(component.isHighestVersion());
 996                 toscaElement.setLastUpdateDate(component.getLastUpdateDate());
 997                 toscaElement.setLastUpdaterFullName(component.getLastUpdaterFullName());
 998                 toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId());
 999                 toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType());
1000                 toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion());
1001
1002                 toscaElement.setLifecycleState(component.getLifecycleState());
1003                 toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion());
1004                 if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
1005                         toscaElement.setMetadataValue(JsonPresentationFields.IS_ABSTRACT, ((Resource) component).isAbstract());
1006                         toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName());
1007                         toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName());
1008                         toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease());
1009                         // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1010                         if (((Resource) component).getResourceVendorModelNumber() != null){
1011                                 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber());
1012                         } else {
1013                                 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, "");
1014                         }
1015                 } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
1016                         // field isn't mandatory , but shouldn't be null(should be an empty string instead)
1017                         if (((Service) component).getServiceType() != null){
1018                                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType());
1019                         } else {
1020                                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, "");
1021                         }
1022                         if (((Service) component).getServiceRole() != null){
1023                                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole());
1024                         } else {
1025                                 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, "");
1026                         }
1027                 }
1028                 toscaElement.setMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL, component.getConformanceLevel());
1029                 toscaElement.setMetadataValue(JsonPresentationFields.IS_DELETED, component.getIsDeleted());
1030                 toscaElement.setMetadataValue(JsonPresentationFields.ICON, component.getIcon());
1031                 toscaElement.setMetadataValue(JsonPresentationFields.DESCRIPTION, component.getDescription());
1032                 toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags());
1033                 toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID());
1034                 toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
1035         }
1036
1037
1038
1039         private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {
1040
1041                 List<ComponentInstance> componentInstances = new ArrayList<>();
1042                 ComponentInstance currComponentInstance;
1043                 for (Map.Entry<String, ComponentInstanceDataDefinition> entry : topologyTemplate.getComponentInstances().entrySet()) {
1044                         String key = entry.getKey();
1045                         currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key));
1046                         if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) {
1047                                 List<GroupInstance> groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList());
1048                                 currComponentInstance.setGroupInstances(groupInstances);
1049                         }
1050                         componentInstances.add(currComponentInstance);
1051                 }
1052                 component.setComponentInstances(componentInstances);
1053         }
1054
1055         private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) {
1056                 if (topologyTemplate.getInstInputs() != null) {
1057                         Map<String, List<ComponentInstanceInput>> inputs = new HashMap<>();
1058                         for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstInputs().entrySet()) {
1059                                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1060                                         String key = entry.getKey();
1061                                         List<ComponentInstanceInput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList());
1062                                         inputs.put(key, componentInstanceAttributes);
1063                                 }
1064                         }
1065                         component.setComponentInstancesInputs(inputs);
1066                 }
1067         }
1068
1069         private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) {
1070                 if (topologyTemplate.getInstProperties() != null) {
1071                         Map<String, List<ComponentInstanceProperty>> properties = new HashMap<>();
1072                         for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstProperties().entrySet()) {
1073                                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1074                                         String key = entry.getKey();
1075                                         List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue())))
1076                                                         .collect(Collectors.toList());
1077                                         properties.put(key, componentInstanceAttributes);
1078                                 }
1079                         }
1080                         component.setComponentInstancesProperties(properties);
1081                 }
1082         }
1083
1084         private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) {
1085                 if (topologyTemplate.getInstAttributes() != null) {
1086                         Map<String, List<ComponentInstanceProperty>> attributes = new HashMap<>();
1087                         for (Map.Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstAttributes().entrySet()) {
1088                                 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1089                                         String key = entry.getKey();
1090                                         List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new ComponentInstanceProperty(e.getValue())))
1091                                                         .collect(Collectors.toList());
1092                                         attributes.put(key, componentInstanceAttributes);
1093                                 }
1094                         }
1095                         component.setComponentInstancesAttributes(attributes);
1096                 }
1097         }
1098
1099         private static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
1100
1101                 if (topologyTemplate.getCalculatedRequirements() != null) {
1102                         // Requirements of component organized by capability
1103                         Map<String, List<RequirementDefinition>> instancesRequirements = new HashMap<>();
1104
1105                         Map<String, ComponentInstance> instancesMap = new HashMap<>();
1106                         for (ComponentInstance currInstance : component.getComponentInstances()) {
1107                                 instancesMap.put(currInstance.getUniqueId(), currInstance);
1108                         }
1109                         for (Map.Entry<String, MapListRequirementDataDefinition> entry : topologyTemplate.getCalculatedRequirements().entrySet()) {
1110
1111                                 String instanceId = entry.getKey();
1112                                 // Requirements of instance organized by capability
1113                                 Map<String, ListRequirementDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1114
1115                                 for (Entry<String, ListRequirementDataDefinition> entryTypeList : capsMapList.entrySet()) {
1116                                         String capabilityType = entryTypeList.getKey();
1117                                         List<RequirementDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> new RequirementDefinition(cap)).collect(Collectors.toList());
1118                                         if (instancesRequirements.containsKey(capabilityType)) {
1119                                                 instancesRequirements.get(capabilityType).addAll(caps);
1120                                         } else {
1121                                                 instancesRequirements.put(capabilityType, caps);
1122                                         }
1123                                         if (MapUtils.isEmpty(instancesMap.get(instanceId).getRequirements())) {
1124                                                 instancesMap.get(instanceId).setRequirements(new HashMap<>());
1125                                         }
1126                                         instancesMap.get(instanceId).getRequirements().put(capabilityType, new ArrayList<>(caps));
1127                                 }
1128                         }
1129                         component.setRequirements(instancesRequirements);
1130                 }
1131         }
1132
1133         private static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) {
1134                 Map<String, MapCapabiltyProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1135
1136                 if (topologyTemplate.getCalculatedCapabilities() != null) {
1137                         // capabilities of component organized by type
1138                         Map<String, List<CapabilityDefinition>> instancesCapabilities = new HashMap<>();
1139
1140                         Map<String, ComponentInstance> instancesMap = new HashMap<>();
1141                         for (ComponentInstance currInstance : component.getComponentInstances()) {
1142                                 instancesMap.put(currInstance.getUniqueId(), currInstance);
1143                         }
1144                         for (Map.Entry<String, MapListCapabiltyDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1145
1146                                 String instanceId = entry.getKey();
1147                                 // capabilities of instance organized by type
1148                                 Map<String, ListCapabilityDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1149
1150                                 for (Entry<String, ListCapabilityDataDefinition> entryTypeList : capsMapList.entrySet()) {
1151                                         String capabilityType = entryTypeList.getKey();
1152                                         List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList());
1153                                         if (instancesCapabilities.containsKey(capabilityType)) {
1154                                                 instancesCapabilities.get(capabilityType).addAll(caps);
1155                                         } else {
1156                                                 instancesCapabilities.put(capabilityType, caps);
1157                                         }
1158                                         ComponentInstance instance = instancesMap.get(instanceId);
1159                                         if (instance == null) {
1160                                                 log.error("instance is null for id {} entry {}", instanceId, entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME));
1161                                         } else {
1162                                                 if (MapUtils.isEmpty(instance.getCapabilities())) {
1163                                                         instance.setCapabilities(new HashMap<>());
1164                                                 }
1165                                                 instance.getCapabilities().put(capabilityType, new ArrayList<>(caps));
1166                                         }
1167                                 }
1168                         }
1169                         component.setCapabilities(instancesCapabilities);
1170                 }
1171         }
1172
1173         private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String instance, Map<String, MapCapabiltyProperty> calculatedCapProperties) {
1174                 CapabilityDefinition capability = new CapabilityDefinition(cap);
1175                 if (calculatedCapProperties != null) {
1176                         MapCapabiltyProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(instance);
1177                         if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) {
1178
1179                                 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition();
1180                                 toscaCapPropMap.forEach(new BiConsumer<String, MapPropertiesDataDefinition>() {
1181                                         @Override
1182                                         public void accept(String s, MapPropertiesDataDefinition capProp) {
1183                                                 // format key of capability properties :
1184                                                 // VF instance in service : instanceId#ownerId#type#capName
1185                                                 // VFC instance ion VF : instanceId#type#capName -> instanceId=ownerId
1186                                                 String[] result = s.split(CAP_PROP_DELIM);
1187                                                 if (result.length < 4) {
1188                                                         log.debug("wrong key format for capabilty, key {}", capProp);
1189                                                         return;
1190                                                 }
1191                                                 int instanceIndex = 0;
1192                                                 int ownerIndex = 1;
1193                                                 int typeIndex = result.length - 2;
1194                                                 int nameIndex = result.length - 1;
1195                                                 if (capProp != null) {
1196                                                         if (result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex]) && instance.equals(result[instanceIndex])) {
1197
1198                                                                 Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
1199
1200                                                                 if (capMap != null && !capMap.isEmpty()) {
1201                                                                         // List<PropertyDataDefinition> list = map.values().stream().collect(Collectors.toList());
1202                                                                         List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(o -> {
1203
1204                                                                                 return new ComponentInstanceProperty(o);
1205                                                                         }).collect(Collectors.toList());
1206
1207                                                                         capability.setProperties(capPropsList);
1208                                                                 }
1209                                                         }
1210                                                 }
1211                                         }
1212                                 });
1213                         }
1214                 }
1215                 return capability;
1216         }
1217
1218         private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1219
1220                 Map<String, ComponentInstanceDataDefinition> componentInstances = new HashMap<>();
1221                 ComponentInstanceDataDefinition convertedInstance;
1222                 if (component.getComponentInstances() != null) {
1223                         for (ComponentInstance instance : component.getComponentInstances()) {
1224                                 convertedInstance = new ComponentInstanceDataDefinition(instance);
1225                                 if (instance.getGroupInstances() != null) {
1226                                         MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition();
1227
1228                                         groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(e -> new GroupInstanceDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1229                                         if (topologyTemplate.getInstGroups() == null) {
1230                                                 topologyTemplate.setInstGroups(new HashMap<>());
1231                                         }
1232                                         topologyTemplate.getInstGroups().put(instance.getUniqueId(), groupsMap);
1233                                 }
1234                                 componentInstances.put(instance.getUniqueId(), convertedInstance);
1235                         }
1236                 }
1237                 topologyTemplate.setComponentInstances(componentInstances);
1238
1239         }
1240
1241         private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1242
1243                 if (component.getComponentInstancesInputs() != null) {
1244                         topologyTemplate.setInstInputs(new HashMap<>());
1245                         MapPropertiesDataDefinition inputsMap;
1246                         for (Entry<String, List<ComponentInstanceInput>> entry : component.getComponentInstancesInputs().entrySet()) {
1247                                 inputsMap = new MapPropertiesDataDefinition();
1248
1249                                 inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(e -> new PropertyDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1250
1251                                 topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap);
1252                         }
1253                 }
1254         }
1255
1256         private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1257
1258                 if (component.getComponentInstancesProperties() != null) {
1259                         topologyTemplate.setInstProperties(new HashMap<>());
1260                         MapPropertiesDataDefinition propertiesMap;
1261                         for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesProperties().entrySet()) {
1262                                 propertiesMap = new MapPropertiesDataDefinition();
1263
1264                                 propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(e -> new PropertyDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1265
1266                                 topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap);
1267                         }
1268                 }
1269         }
1270
1271         private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1272
1273                 List<ComponentInstance> componentInstances = component.getComponentInstances();
1274                 if (componentInstances != null) {
1275                         topologyTemplate.setInstanceArtifacts(new HashMap<>());
1276                         topologyTemplate.setInstDeploymentArtifacts(new HashMap<>());
1277
1278                         for (ComponentInstance ci : componentInstances) {
1279                                 Map<String, ArtifactDefinition> artifacts = ci.getArtifacts();
1280                                 if (artifacts != null) {
1281                                         Map<String, ArtifactDataDefinition> mapToscaDataDefinitionArtifact = artifacts.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), e -> new ArtifactDataDefinition(e.getValue())));
1282                                         MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact);
1283                                         topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact);
1284                                 }
1285
1286                                 Map<String, ArtifactDefinition> deplArtifacts = ci.getDeploymentArtifacts();
1287                                 if (deplArtifacts != null) {
1288                                         Map<String, ArtifactDataDefinition> mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), e -> new ArtifactDataDefinition(e.getValue())));
1289                                         MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact);
1290                                         topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact);
1291                                 }
1292                         }
1293                 }
1294         }
1295
1296         private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1297
1298                 if (component.getComponentInstancesAttributes() != null) {
1299                         topologyTemplate.setInstAttributes(new HashMap<>());
1300                         MapPropertiesDataDefinition attributesMap;
1301                         for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesAttributes().entrySet()) {
1302                                 attributesMap = new MapPropertiesDataDefinition();
1303
1304                                 attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(e -> new PropertyDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1305
1306                                 topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap);
1307                         }
1308                 }
1309         }
1310
1311         public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) {
1312                 ComponentMetadataData metadata = null;
1313                 switch (vertex.getType()) {
1314                 case SERVICE:
1315                         metadata = new ServiceMetadataData(vertex.getMetadataJson());
1316                         break;
1317                 case RESOURCE:
1318                         metadata = new ResourceMetadataData(vertex.getMetadataJson());
1319                         break;
1320                 case PRODUCT:
1321                         metadata = new ProductMetadataData(vertex.getMetadataJson());
1322                         break;
1323                 default:
1324                         break;
1325                 }
1326                 if (metadata != null) {
1327                         metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId());
1328                         metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
1329                         metadata.getMetadataDataDefinition().setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID));
1330                         metadata.getMetadataDataDefinition().setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE));
1331                 }
1332                 return metadata;
1333         }
1334
1335         public static List<GroupDefinition> convertToGroupDefinitions(Map<String, GroupDataDefinition> groups) {
1336
1337                 List<GroupDefinition> groupDefinitions = null;
1338                 if (MapUtils.isNotEmpty(groups)) {
1339                         groupDefinitions = groups.values().stream().map(g -> new GroupDefinition(g)).collect(Collectors.toList());
1340                 }
1341                 return groupDefinitions;
1342         }
1343
1344 }