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

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