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