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

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