catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/UiComponentDataConverter.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.datamodel.utils;
  22
  23 import static java.util.stream.Collectors.groupingBy;
  24 import static java.util.stream.Collectors.toList;
  25
  26 import java.util.ArrayList;
  27 import java.util.Collection;
  28 import java.util.HashMap;
  29 import java.util.HashSet;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Set;
  33 import java.util.stream.Collectors;
  34 import org.apache.commons.collections.CollectionUtils;
  35 import org.apache.commons.collections.MapUtils;
  36 import org.openecomp.sdc.be.components.impl.GroupTypeBusinessLogic;
  37 import org.openecomp.sdc.be.components.impl.PolicyTypeBusinessLogic;
  38 import org.openecomp.sdc.be.components.validation.PolicyUtils;
  39 import org.openecomp.sdc.be.datatypes.components.ResourceMetadataDataDefinition;
  40 import org.openecomp.sdc.be.datatypes.components.ServiceMetadataDataDefinition;
  41 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
  42 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
  43 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  44 import org.openecomp.sdc.be.model.CapabilityDefinition;
  45 import org.openecomp.sdc.be.model.Component;
  46 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  47 import org.openecomp.sdc.be.model.GroupDefinition;
  48 import org.openecomp.sdc.be.model.PolicyDefinition;
  49 import org.openecomp.sdc.be.model.Resource;
  50 import org.openecomp.sdc.be.model.Service;
  51 import org.openecomp.sdc.be.tosca.utils.NodeFilterConverter;
  52 import org.openecomp.sdc.be.tosca.utils.SubstitutionFilterConverter;
  53 import org.openecomp.sdc.be.ui.model.UINodeFilter;
  54 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
  55 import org.openecomp.sdc.be.ui.model.UiComponentMetadata;
  56 import org.openecomp.sdc.be.ui.model.UiResourceDataTransfer;
  57 import org.openecomp.sdc.be.ui.model.UiResourceMetadata;
  58 import org.openecomp.sdc.be.ui.model.UiServiceDataTransfer;
  59 import org.openecomp.sdc.be.ui.model.UiServiceMetadata;
  60 import org.openecomp.sdc.common.log.wrappers.Logger;
  61
  62 @org.springframework.stereotype.Component("uiComponentDataConverter")
  63 public class UiComponentDataConverter {
  64
  65     private static final Logger log = Logger.getLogger(UiComponentDataConverter.class);
  66     public static final String INVALID_INPUT_GIVEN_TO_DATA_CONVERTER = "Invalid input given to data converter: {}";
  67     private final GroupTypeBusinessLogic groupTypeBusinessLogic;
  68     private final PolicyTypeBusinessLogic policyTypeBusinessLogic;
  69
  70     public UiComponentDataConverter(GroupTypeBusinessLogic groupTypeBusinessLogic,
  71                                     PolicyTypeBusinessLogic policyTypeBusinessLogic) {
  72         this.groupTypeBusinessLogic = groupTypeBusinessLogic;
  73         this.policyTypeBusinessLogic = policyTypeBusinessLogic;
  74     }
  75
  76     private void setUiTranferDataByFieldName(UiComponentDataTransfer dataTransfer, Component component,
  77                                              String fieldName) {
  78         ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
  79         if (field == null) {
  80             log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
  81             return;
  82         }
  83         switch (field) {
  84             case INPUTS:
  85                 setInputs(dataTransfer, component);
  86                 break;
  87             case COMPONENT_INSTANCE_RELATION:
  88                 setComponentInstanceRelation(dataTransfer, component);
  89                 break;
  90             case GROUPS:
  91                 setGroups(dataTransfer, component);
  92                 break;
  93             case NON_EXCLUDED_GROUPS:
  94                 setNonExcludedGroups(dataTransfer, component);
  95                 break;
  96             case COMPONENT_INSTANCES:
  97                 setComponentInstances(dataTransfer, component);
  98                 break;
  99             case COMPONENT_INSTANCES_PROPERTIES:
 100                 setComponentInstanceProperties(dataTransfer, component);
 101                 break;
 102             case CAPABILITIES:
 103                 setCapabilities(dataTransfer, component);
 104                 break;
 105             case POLICIES:
 106                 setPolicies(dataTransfer, component);
 107                 break;
 108             case NON_EXCLUDED_POLICIES:
 109                 setNonExcludedPolicies(dataTransfer, component);
 110                 break;
 111             case REQUIREMENTS:
 112                 setRequirements(dataTransfer, component);
 113                 break;
 114             case DEPLOYMENT_ARTIFACTS:
 115                 setDeploymentArtifacts(dataTransfer, component);
 116                 break;
 117             case TOSCA_ARTIFACTS:
 118                 setToscaArtifacts(dataTransfer, component);
 119                 break;
 120             case ARTIFACTS:
 121                 setArtifacts(dataTransfer, component);
 122                 break;
 123             case COMPONENT_INSTANCES_ATTRIBUTES:
 124                 setComponentInstanceAttributes(dataTransfer, component);
 125                 break;
 126             case COMPONENT_INSTANCE_INPUTS:
 127                 setComponentInstanceInputs(dataTransfer, component);
 128                 break;
 129             case NODE_FILTER:
 130                 setNodeFilter(dataTransfer, component);
 131                 break;
 132             case SUBSTITUTION_FILTER:
 133                 setSubstitutionFilter(dataTransfer, component);
 134                 break;
 135             case COMPONENT_INSTANCES_INTERFACES:
 136                 setComponentInstanceInterfaces(dataTransfer, component);
 137                 break;
 138             case PROPERTIES:
 139                 setProperties(dataTransfer, component);
 140                 break;
 141             case INTERFACES:
 142                 setInterfaces(dataTransfer, component);
 143                 break;
 144             default:
 145                 break;
 146         }
 147     }
 148
 149     private void setNodeFilter(UiComponentDataTransfer dataTransfer, Component component) {
 150         if (component.getNodeFilterComponents() == null) {
 151             dataTransfer.setNodeFilter(null);
 152         } else {
 153             dataTransfer.setNodeFilter(component.getNodeFilterComponents());
 154         }
 155     }
 156
 157     private void setSubstitutionFilter(final UiComponentDataTransfer dataTransfer,
 158                                        final Component component) {
 159         if (component.getSubstitutionFilterComponents() == null) {
 160             dataTransfer.setSubstitutionFilter(null);
 161         } else {
 162             dataTransfer.setSubstitutionFilter(component.getSubstitutionFilterComponents());
 163         }
 164     }
 165
 166     private void setPolicies(UiComponentDataTransfer dataTransfer, Component component) {
 167         Map<String, PolicyDefinition> policies = component.getPolicies();
 168         Set<PolicyDefinition> policyDefinitions =
 169             MapUtils.isEmpty(policies) ? new HashSet<>() : new HashSet<>(policies.values());
 170
 171         policyDefinitions.addAll(getDeclaredPolicies(component.getComponentInstancesProperties()));
 172
 173         dataTransfer.setPolicies(new ArrayList<>(policyDefinitions));
 174     }
 175
 176     private Set<PolicyDefinition> getDeclaredPolicies(
 177         Map<String, List<ComponentInstanceProperty>> componentInstanceProperties) {
 178         if (MapUtils.isEmpty(componentInstanceProperties)) {
 179             return new HashSet<>();
 180         }
 181
 182         Set<PolicyDefinition> declaredPolicies = new HashSet<>();
 183         for (Map.Entry<String, List<ComponentInstanceProperty>> instancePropertyEntry : componentInstanceProperties
 184             .entrySet()) {
 185             declaredPolicies.addAll(instancePropertyEntry.getValue().stream()
 186                 .filter(property -> CollectionUtils.isNotEmpty(property.getGetPolicyValues()))
 187                 .map(instanceProperty -> PolicyUtils
 188                     .getDeclaredPolicyDefinition(instancePropertyEntry.getKey(), instanceProperty))
 189                 .collect(Collectors.toSet()));
 190         }
 191
 192         return declaredPolicies;
 193     }
 194
 195
 196     private void setComponentInstanceRelation(UiComponentDataTransfer dataTransfer, Component component) {
 197         if (component.getComponentInstancesRelations() == null) {
 198             dataTransfer.setComponentInstancesRelations(new ArrayList<>());
 199         } else {
 200             dataTransfer.setComponentInstancesRelations(component.getComponentInstancesRelations());
 201         }
 202     }
 203
 204     private void setInputs(UiComponentDataTransfer dataTransfer, Component component) {
 205         if (component.getInputs() == null) {
 206             dataTransfer.setInputs(new ArrayList<>());
 207         } else {
 208             dataTransfer.setInputs(component.getInputs());
 209         }
 210     }
 211
 212     private void setComponentInstanceInputs(UiComponentDataTransfer dataTransfer, Component component) {
 213         if (component.getComponentInstancesInputs() == null) {
 214             dataTransfer.setComponentInstancesInputs(new HashMap<>());
 215         } else {
 216             dataTransfer.setComponentInstancesInputs(component.getComponentInstancesInputs());
 217         }
 218     }
 219
 220     private void setComponentInstanceAttributes(UiComponentDataTransfer dataTransfer, Component component) {
 221         if (component.getComponentInstancesAttributes() == null) {
 222             dataTransfer.setComponentInstancesAttributes(new HashMap<>());
 223         } else {
 224             dataTransfer.setComponentInstancesAttributes(component.getComponentInstancesAttributes());
 225         }
 226     }
 227
 228     private void setArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
 229         if (component.getArtifacts() == null) {
 230             dataTransfer.setArtifacts(new HashMap<>());
 231         } else {
 232             dataTransfer.setArtifacts(component.getArtifacts());
 233         }
 234     }
 235
 236     private void setToscaArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
 237         if (component.getToscaArtifacts() == null) {
 238             dataTransfer.setToscaArtifacts(new HashMap<>());
 239         } else {
 240             dataTransfer.setToscaArtifacts(component.getToscaArtifacts());
 241         }
 242     }
 243
 244     private void setDeploymentArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
 245         if (component.getDeploymentArtifacts() == null) {
 246             dataTransfer.setDeploymentArtifacts(new HashMap<>());
 247         } else {
 248             dataTransfer.setDeploymentArtifacts(component.getDeploymentArtifacts());
 249         }
 250     }
 251
 252     private void setRequirements(UiComponentDataTransfer dataTransfer, Component component) {
 253         if (component.getRequirements() == null) {
 254             dataTransfer.setRequirements(new HashMap<>());
 255         } else {
 256             dataTransfer.setRequirements(component.getRequirements());
 257         }
 258     }
 259
 260     private void setCapabilities(UiComponentDataTransfer dataTransfer, Component component) {
 261         if (component.getCapabilities() == null) {
 262             dataTransfer.setCapabilities(new HashMap<>());
 263         } else {
 264             dataTransfer.setCapabilities(getFilteredCapabilities(component));
 265         }
 266     }
 267
 268     private Map<String, List<CapabilityDefinition>> getFilteredCapabilities(Component component) {
 269         if (component.getComponentType() != ComponentTypeEnum.SERVICE) {
 270             return component.getCapabilities().values()
 271                 .stream()
 272                 .flatMap(Collection::stream)
 273                 .filter(c -> c.getOwnerType() != CapabilityDataDefinition.OwnerType.GROUP)
 274                 .collect(groupingBy(CapabilityDefinition::getType, toList()));
 275         }
 276         return component.getCapabilities();
 277     }
 278
 279     private void setComponentInstanceProperties(UiComponentDataTransfer dataTransfer, Component component) {
 280         if (component.getComponentInstancesProperties() == null) {
 281             dataTransfer.setComponentInstancesProperties(new HashMap<>());
 282         } else {
 283             dataTransfer.setComponentInstancesProperties(component.getComponentInstancesProperties());
 284         }
 285     }
 286
 287     private void setComponentInstances(UiComponentDataTransfer dataTransfer, Component component) {
 288         if (component.getComponentInstances() == null) {
 289             dataTransfer.setComponentInstances(new ArrayList<>());
 290         } else {
 291             dataTransfer.setComponentInstances(component.getComponentInstances());
 292         }
 293     }
 294
 295     private void setGroups(UiComponentDataTransfer dataTransfer, Component component) {
 296         if (component.getGroups() == null) {
 297             dataTransfer.setGroups(new ArrayList<>());
 298         } else {
 299             dataTransfer.setGroups(component.getGroups());
 300         }
 301     }
 302
 303     private void setProperties(UiComponentDataTransfer dataTransfer, Component component) {
 304         if (component.getProperties() == null) {
 305             dataTransfer.setProperties(new ArrayList<>());
 306         } else {
 307             dataTransfer.setProperties(component.getProperties());
 308         }
 309     }
 310
 311     private void setInterfaces(UiComponentDataTransfer dataTransfer, Component component) {
 312         if (component.getInterfaces() == null) {
 313             dataTransfer.setInterfaces(new HashMap<>());
 314         } else {
 315             dataTransfer.setInterfaces(component.getInterfaces());
 316         }
 317     }
 318
 319     private void setComponentInstanceInterfaces(UiComponentDataTransfer dataTransfer, Component component) {
 320         if (component.getComponentInstancesInterfaces() == null) {
 321             dataTransfer.setComponentInstancesInterfaces(new HashMap<>());
 322         } else {
 323             dataTransfer.setComponentInstancesInterfaces(component.getComponentInstancesInterfaces());
 324         }
 325     }
 326
 327     private void setNonExcludedGroups(UiComponentDataTransfer dataTransfer, Component component) {
 328         List<GroupDefinition> groups = component.getGroups();
 329         if (groups == null) {
 330             dataTransfer.setGroups(new ArrayList<>());
 331         } else {
 332             Set<String> nonExcludedGroupTypes = groupTypeBusinessLogic
 333                 .getExcludedGroupTypes(component.getActualComponentType());
 334             List<GroupDefinition> nonExcludedGroups = groups.stream()
 335                 .filter(gd -> !nonExcludedGroupTypes.contains(gd.getType()))
 336                 .collect(toList());
 337             dataTransfer.setGroups(nonExcludedGroups);
 338         }
 339     }
 340
 341     private void setNonExcludedPolicies(UiComponentDataTransfer dataTransfer, Component component) {
 342         List<PolicyDefinition> policyDefinitions = component.resolvePoliciesList();
 343         Set<String> nonExcludedPolicyTypes = policyTypeBusinessLogic
 344             .getExcludedPolicyTypes(component.getActualComponentType());
 345         List<PolicyDefinition> nonExcludedPolicies = policyDefinitions.stream()
 346             .filter(pd -> !nonExcludedPolicyTypes.contains(pd.getPolicyTypeName()))
 347             .collect(toList());
 348         dataTransfer.setPolicies(nonExcludedPolicies);
 349     }
 350
 351     public UiComponentDataTransfer getUiDataTransferFromResourceByParams(Resource resource,
 352                                                                          List<String> paramsToReturn) {
 353         UiResourceDataTransfer dataTransfer = new UiResourceDataTransfer();
 354
 355         for (String fieldName : paramsToReturn) {
 356
 357             ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
 358             if (field == null) {
 359                 log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
 360                 continue;
 361             }
 362             switch (field) {
 363                 case DERIVED_FROM:
 364                     setDerivedFrom(resource, dataTransfer);
 365                     break;
 366
 367                 case ATTRIBUTES:
 368                     setAttributes(resource, dataTransfer);
 369                     break;
 370
 371                 case ADDITIONAL_INFORMATION:
 372                     setAdditionalInfo(resource, dataTransfer);
 373                     break;
 374                 case METADATA:
 375                     UiResourceMetadata metadata = new UiResourceMetadata(resource.getCategories(),
 376                         resource.getDerivedFrom(),
 377                         (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition()
 378                             .getMetadataDataDefinition());
 379                     dataTransfer.setMetadata(metadata);
 380                     break;
 381                 case SUBSTITUTION_FILTER:
 382                     if (resource.getSubstitutionFilter() == null) {
 383                         dataTransfer.setSubstitutionFilterForTopologyTemplate(null);
 384                     } else {
 385                         final SubstitutionFilterConverter substitutionFilterConverter = new SubstitutionFilterConverter();
 386                         final Map<String, UINodeFilter> filterUiMap = new HashMap<>();
 387                         filterUiMap.put(resource.getUniqueId(),
 388                                 substitutionFilterConverter.convertToUi(resource.getSubstitutionFilter()));
 389                         dataTransfer.setSubstitutionFilterForTopologyTemplate(filterUiMap);
 390                     }
 391                     break;
 392
 393                 case NODE_FILTER:
 394                     if (resource.getNodeFilterComponents() == null) {
 395                         dataTransfer.setNodeFilterforNode(null);
 396                     } else {
 397                         final NodeFilterConverter nodeFilterConverter = new NodeFilterConverter();
 398                         dataTransfer.setNodeFilterforNode(
 399                             nodeFilterConverter.convertDataMapToUI(resource.getNodeFilterComponents()));
 400                     }
 401                     break;
 402
 403                 default:
 404                     setUiTranferDataByFieldName(dataTransfer, resource, fieldName);
 405             }
 406         }
 407
 408         return dataTransfer;
 409     }
 410
 411     private void setDerivedFrom(Resource resource, UiResourceDataTransfer dataTransfer) {
 412         if (resource.getDerivedFrom() == null) {
 413             dataTransfer.setDerivedFrom(new ArrayList<>());
 414         } else {
 415             dataTransfer.setDerivedFrom(resource.getDerivedFrom());
 416         }
 417     }
 418
 419     private void setAttributes(Resource resource, UiResourceDataTransfer dataTransfer) {
 420         if (resource.getAttributes() == null) {
 421             dataTransfer.setAttributes(new ArrayList<>());
 422         } else {
 423             dataTransfer.setAttributes(resource.getAttributes());
 424         }
 425     }
 426
 427     private void setAdditionalInfo(Resource resource, UiResourceDataTransfer dataTransfer) {
 428         if (resource.getAdditionalInformation() == null) {
 429             dataTransfer.setAdditionalInformation(new ArrayList<>());
 430         } else {
 431             dataTransfer.setAdditionalInformation(resource.getAdditionalInformation());
 432         }
 433     }
 434
 435     public UiComponentDataTransfer getUiDataTransferFromServiceByParams(Service service, List<String> paramsToReturn) {
 436         UiServiceDataTransfer dataTransfer = new UiServiceDataTransfer();
 437         for (String fieldName : paramsToReturn) {
 438             ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
 439             if (field == null) {
 440                 log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
 441                 continue;
 442             }
 443             switch (field) {
 444                 case SERVICE_API_ARTIFACTS:
 445                     setServiceApiArtifacts(service, dataTransfer);
 446                     break;
 447                 case FORWARDING_PATHS:
 448                     setForwardingPaths(service, dataTransfer);
 449                     break;
 450                 case METADATA:
 451                     UiServiceMetadata metadata = new UiServiceMetadata(service.getCategories(),
 452                         (ServiceMetadataDataDefinition) service.getComponentMetadataDefinition()
 453                             .getMetadataDataDefinition());
 454                     dataTransfer.setMetadata(metadata);
 455                     break;
 456                 case NODE_FILTER:
 457                     if (service.getNodeFilterComponents() == null) {
 458                         dataTransfer.setNodeFilterforNode(null);
 459                     } else {
 460                         final NodeFilterConverter nodeFilterConverter = new NodeFilterConverter();
 461                         dataTransfer.setNodeFilterforNode(
 462                             nodeFilterConverter.convertDataMapToUI(service.getNodeFilterComponents()));
 463                     }
 464                     break;
 465                 case SUBSTITUTION_FILTER:
 466                     if (service.getSubstitutionFilter() == null) {
 467                         dataTransfer.setSubstitutionFilterForTopologyTemplate(null);
 468                     } else {
 469                         final SubstitutionFilterConverter substitutionFilterConverter = new SubstitutionFilterConverter();
 470                         final Map<String, UINodeFilter> filterUiMap = new HashMap<>();
 471                         filterUiMap.put(service.getUniqueId(),
 472                             substitutionFilterConverter.convertToUi(service.getSubstitutionFilter()));
 473                         dataTransfer.setSubstitutionFilterForTopologyTemplate(filterUiMap);
 474                     }
 475                     break;
 476                 default:
 477                     setUiTranferDataByFieldName(dataTransfer, service, fieldName);
 478             }
 479         }
 480         return dataTransfer;
 481     }
 482
 483     private void setServiceApiArtifacts(Service service, UiServiceDataTransfer dataTransfer) {
 484         if (service.getServiceApiArtifacts() == null) {
 485             dataTransfer.setServiceApiArtifacts(new org.openecomp.sdc.be.ui.model.SerializedHashMap<>());
 486         } else {
 487             dataTransfer.setServiceApiArtifacts(service.getServiceApiArtifacts());
 488         }
 489     }
 490
 491     private void setForwardingPaths(Service service, UiServiceDataTransfer dataTransfer) {
 492         if (service.getForwardingPaths() == null) {
 493             dataTransfer.setForwardingPaths(new org.openecomp.sdc.be.ui.model.SerializedHashMap<>());
 494         } else {
 495             dataTransfer.setForwardingPaths(service.getForwardingPaths());
 496         }
 497     }
 498
 499     public static UiComponentMetadata convertToUiComponentMetadata(Component component) {
 500
 501         UiComponentMetadata uiComponentMetadata = null;
 502         switch (component.getComponentType()) {
 503             case RESOURCE:
 504                 Resource resource = (Resource) component;
 505                 uiComponentMetadata = new UiResourceMetadata(component.getCategories(), resource.getDerivedFrom(),
 506                     (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition()
 507                         .getMetadataDataDefinition());
 508                 break;
 509             case SERVICE:
 510                 uiComponentMetadata = new UiServiceMetadata(component.getCategories(),
 511                     (ServiceMetadataDataDefinition) component.getComponentMetadataDefinition()
 512                         .getMetadataDataDefinition());
 513                 break;
 514             default:
 515                 break;
 516         }
 517         return uiComponentMetadata;
 518     }
 519 }