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