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