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 ATTRIBUTES:
 142                 setAttributes(dataTransfer, component);
 143                 break;
 144             case INTERFACES:
 145                 setInterfaces(dataTransfer, component);
 146                 break;
 147             default:
 148                 break;
 149         }
 150     }
 151
 152     private void setNodeFilter(UiComponentDataTransfer dataTransfer, Component component) {
 153         if (component.getNodeFilterComponents() == null) {
 154             dataTransfer.setNodeFilter(null);
 155         } else {
 156             dataTransfer.setNodeFilter(component.getNodeFilterComponents());
 157         }
 158     }
 159
 160     private void setSubstitutionFilter(final UiComponentDataTransfer dataTransfer,
 161                                        final Component component) {
 162         if (component.getSubstitutionFilterComponents() == null) {
 163             dataTransfer.setSubstitutionFilter(null);
 164         } else {
 165             dataTransfer.setSubstitutionFilter(component.getSubstitutionFilterComponents());
 166         }
 167     }
 168
 169     private void setPolicies(UiComponentDataTransfer dataTransfer, Component component) {
 170         Map<String, PolicyDefinition> policies = component.getPolicies();
 171         Set<PolicyDefinition> policyDefinitions =
 172             MapUtils.isEmpty(policies) ? new HashSet<>() : new HashSet<>(policies.values());
 173
 174         policyDefinitions.addAll(getDeclaredPolicies(component.getComponentInstancesProperties()));
 175
 176         dataTransfer.setPolicies(new ArrayList<>(policyDefinitions));
 177     }
 178
 179     private Set<PolicyDefinition> getDeclaredPolicies(
 180         Map<String, List<ComponentInstanceProperty>> componentInstanceProperties) {
 181         if (MapUtils.isEmpty(componentInstanceProperties)) {
 182             return new HashSet<>();
 183         }
 184
 185         Set<PolicyDefinition> declaredPolicies = new HashSet<>();
 186         for (Map.Entry<String, List<ComponentInstanceProperty>> instancePropertyEntry : componentInstanceProperties
 187             .entrySet()) {
 188             declaredPolicies.addAll(instancePropertyEntry.getValue().stream()
 189                 .filter(property -> CollectionUtils.isNotEmpty(property.getGetPolicyValues()))
 190                 .map(instanceProperty -> PolicyUtils
 191                     .getDeclaredPolicyDefinition(instancePropertyEntry.getKey(), instanceProperty))
 192                 .collect(Collectors.toSet()));
 193         }
 194
 195         return declaredPolicies;
 196     }
 197
 198
 199     private void setComponentInstanceRelation(UiComponentDataTransfer dataTransfer, Component component) {
 200         if (component.getComponentInstancesRelations() == null) {
 201             dataTransfer.setComponentInstancesRelations(new ArrayList<>());
 202         } else {
 203             dataTransfer.setComponentInstancesRelations(component.getComponentInstancesRelations());
 204         }
 205     }
 206
 207     private void setInputs(UiComponentDataTransfer dataTransfer, Component component) {
 208         if (component.getInputs() == null) {
 209             dataTransfer.setInputs(new ArrayList<>());
 210         } else {
 211             dataTransfer.setInputs(component.getInputs());
 212         }
 213     }
 214
 215     private void setComponentInstanceInputs(UiComponentDataTransfer dataTransfer, Component component) {
 216         if (component.getComponentInstancesInputs() == null) {
 217             dataTransfer.setComponentInstancesInputs(new HashMap<>());
 218         } else {
 219             dataTransfer.setComponentInstancesInputs(component.getComponentInstancesInputs());
 220         }
 221     }
 222
 223     private void setComponentInstanceAttributes(UiComponentDataTransfer dataTransfer, Component component) {
 224         if (component.getComponentInstancesAttributes() == null) {
 225             dataTransfer.setComponentInstancesAttributes(new HashMap<>());
 226         } else {
 227             dataTransfer.setComponentInstancesAttributes(component.getComponentInstancesAttributes());
 228         }
 229     }
 230
 231     private void setArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
 232         if (component.getArtifacts() == null) {
 233             dataTransfer.setArtifacts(new HashMap<>());
 234         } else {
 235             dataTransfer.setArtifacts(component.getArtifacts());
 236         }
 237     }
 238
 239     private void setToscaArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
 240         if (component.getToscaArtifacts() == null) {
 241             dataTransfer.setToscaArtifacts(new HashMap<>());
 242         } else {
 243             dataTransfer.setToscaArtifacts(component.getToscaArtifacts());
 244         }
 245     }
 246
 247     private void setDeploymentArtifacts(UiComponentDataTransfer dataTransfer, Component component) {
 248         if (component.getDeploymentArtifacts() == null) {
 249             dataTransfer.setDeploymentArtifacts(new HashMap<>());
 250         } else {
 251             dataTransfer.setDeploymentArtifacts(component.getDeploymentArtifacts());
 252         }
 253     }
 254
 255     private void setRequirements(UiComponentDataTransfer dataTransfer, Component component) {
 256         if (component.getRequirements() == null) {
 257             dataTransfer.setRequirements(new HashMap<>());
 258         } else {
 259             dataTransfer.setRequirements(component.getRequirements());
 260         }
 261     }
 262
 263     private void setCapabilities(UiComponentDataTransfer dataTransfer, Component component) {
 264         if (component.getCapabilities() == null) {
 265             dataTransfer.setCapabilities(new HashMap<>());
 266         } else {
 267             dataTransfer.setCapabilities(getFilteredCapabilities(component));
 268         }
 269     }
 270
 271     private Map<String, List<CapabilityDefinition>> getFilteredCapabilities(Component component) {
 272         if (component.getComponentType() != ComponentTypeEnum.SERVICE) {
 273             return component.getCapabilities().values()
 274                 .stream()
 275                 .flatMap(Collection::stream)
 276                 .filter(c -> c.getOwnerType() != CapabilityDataDefinition.OwnerType.GROUP)
 277                 .collect(groupingBy(CapabilityDefinition::getType, toList()));
 278         }
 279         return component.getCapabilities();
 280     }
 281
 282     private void setComponentInstanceProperties(UiComponentDataTransfer dataTransfer, Component component) {
 283         if (component.getComponentInstancesProperties() == null) {
 284             dataTransfer.setComponentInstancesProperties(new HashMap<>());
 285         } else {
 286             dataTransfer.setComponentInstancesProperties(component.getComponentInstancesProperties());
 287         }
 288     }
 289
 290     private void setComponentInstances(UiComponentDataTransfer dataTransfer, Component component) {
 291         if (component.getComponentInstances() == null) {
 292             dataTransfer.setComponentInstances(new ArrayList<>());
 293         } else {
 294             dataTransfer.setComponentInstances(component.getComponentInstances());
 295         }
 296     }
 297
 298     private void setGroups(UiComponentDataTransfer dataTransfer, Component component) {
 299         if (component.getGroups() == null) {
 300             dataTransfer.setGroups(new ArrayList<>());
 301         } else {
 302             dataTransfer.setGroups(component.getGroups());
 303         }
 304     }
 305
 306     private void setProperties(UiComponentDataTransfer dataTransfer, Component component) {
 307         if (component.getProperties() == null) {
 308             dataTransfer.setProperties(new ArrayList<>());
 309         } else {
 310             dataTransfer.setProperties(component.getProperties());
 311         }
 312     }
 313
 314     private void setAttributes(final UiComponentDataTransfer dataTransfer, final Component component) {
 315         if (component.getAttributes() == null) {
 316             dataTransfer.setAttributes(new ArrayList<>());
 317         } else {
 318             dataTransfer.setAttributes(component.getAttributes());
 319         }
 320     }
 321
 322     private void setInterfaces(UiComponentDataTransfer dataTransfer, Component component) {
 323         if (component.getInterfaces() == null) {
 324             dataTransfer.setInterfaces(new HashMap<>());
 325         } else {
 326             dataTransfer.setInterfaces(component.getInterfaces());
 327         }
 328     }
 329
 330     private void setComponentInstanceInterfaces(UiComponentDataTransfer dataTransfer, Component component) {
 331         if (component.getComponentInstancesInterfaces() == null) {
 332             dataTransfer.setComponentInstancesInterfaces(new HashMap<>());
 333         } else {
 334             dataTransfer.setComponentInstancesInterfaces(component.getComponentInstancesInterfaces());
 335         }
 336     }
 337
 338     private void setNonExcludedGroups(UiComponentDataTransfer dataTransfer, Component component) {
 339         List<GroupDefinition> groups = component.getGroups();
 340         if (groups == null) {
 341             dataTransfer.setGroups(new ArrayList<>());
 342         } else {
 343             Set<String> nonExcludedGroupTypes = groupTypeBusinessLogic
 344                 .getExcludedGroupTypes(component.getActualComponentType());
 345             List<GroupDefinition> nonExcludedGroups = groups.stream()
 346                 .filter(gd -> !nonExcludedGroupTypes.contains(gd.getType()))
 347                 .collect(toList());
 348             dataTransfer.setGroups(nonExcludedGroups);
 349         }
 350     }
 351
 352     private void setNonExcludedPolicies(UiComponentDataTransfer dataTransfer, Component component) {
 353         List<PolicyDefinition> policyDefinitions = component.resolvePoliciesList();
 354         Set<String> nonExcludedPolicyTypes = policyTypeBusinessLogic
 355             .getExcludedPolicyTypes(component.getActualComponentType());
 356         List<PolicyDefinition> nonExcludedPolicies = policyDefinitions.stream()
 357             .filter(pd -> !nonExcludedPolicyTypes.contains(pd.getPolicyTypeName()))
 358             .collect(toList());
 359         dataTransfer.setPolicies(nonExcludedPolicies);
 360     }
 361
 362     public UiComponentDataTransfer getUiDataTransferFromResourceByParams(Resource resource,
 363                                                                          List<String> paramsToReturn) {
 364         UiResourceDataTransfer dataTransfer = new UiResourceDataTransfer();
 365
 366         for (String fieldName : paramsToReturn) {
 367
 368             ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
 369             if (field == null) {
 370                 log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
 371                 continue;
 372             }
 373             switch (field) {
 374                 case DERIVED_FROM:
 375                     setDerivedFrom(resource, dataTransfer);
 376                     break;
 377
 378                 case ATTRIBUTES:
 379                     setAttributes(resource, dataTransfer);
 380                     break;
 381
 382                 case ADDITIONAL_INFORMATION:
 383                     setAdditionalInfo(resource, dataTransfer);
 384                     break;
 385                 case METADATA:
 386                     UiResourceMetadata metadata = new UiResourceMetadata(resource.getCategories(),
 387                         resource.getDerivedFrom(),
 388                         (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition()
 389                             .getMetadataDataDefinition());
 390                     dataTransfer.setMetadata(metadata);
 391                     break;
 392                 case SUBSTITUTION_FILTER:
 393                     if (resource.getSubstitutionFilter() == null) {
 394                         dataTransfer.setSubstitutionFilterForTopologyTemplate(null);
 395                     } else {
 396                         final SubstitutionFilterConverter substitutionFilterConverter = new SubstitutionFilterConverter();
 397                         final Map<String, UINodeFilter> filterUiMap = new HashMap<>();
 398                         filterUiMap.put(resource.getUniqueId(),
 399                             substitutionFilterConverter.convertToUi(resource.getSubstitutionFilter()));
 400                         dataTransfer.setSubstitutionFilterForTopologyTemplate(filterUiMap);
 401                     }
 402                     break;
 403
 404                 case NODE_FILTER:
 405                     if (resource.getNodeFilterComponents() == null) {
 406                         dataTransfer.setNodeFilterforNode(null);
 407                     } else {
 408                         final NodeFilterConverter nodeFilterConverter = new NodeFilterConverter();
 409                         dataTransfer.setNodeFilterforNode(
 410                             nodeFilterConverter.convertDataMapToUI(resource.getNodeFilterComponents()));
 411                     }
 412                     break;
 413
 414                 default:
 415                     setUiTranferDataByFieldName(dataTransfer, resource, fieldName);
 416             }
 417         }
 418
 419         return dataTransfer;
 420     }
 421
 422     private void setDerivedFrom(Resource resource, UiResourceDataTransfer dataTransfer) {
 423         if (resource.getDerivedFrom() == null) {
 424             dataTransfer.setDerivedFrom(new ArrayList<>());
 425         } else {
 426             dataTransfer.setDerivedFrom(resource.getDerivedFrom());
 427         }
 428     }
 429
 430     private void setAttributes(Resource resource, UiResourceDataTransfer dataTransfer) {
 431         if (resource.getAttributes() == null) {
 432             dataTransfer.setAttributes(new ArrayList<>());
 433         } else {
 434             dataTransfer.setAttributes(resource.getAttributes());
 435         }
 436     }
 437
 438     private void setAdditionalInfo(Resource resource, UiResourceDataTransfer dataTransfer) {
 439         if (resource.getAdditionalInformation() == null) {
 440             dataTransfer.setAdditionalInformation(new ArrayList<>());
 441         } else {
 442             dataTransfer.setAdditionalInformation(resource.getAdditionalInformation());
 443         }
 444     }
 445
 446     public UiComponentDataTransfer getUiDataTransferFromServiceByParams(Service service, List<String> paramsToReturn) {
 447         UiServiceDataTransfer dataTransfer = new UiServiceDataTransfer();
 448         for (String fieldName : paramsToReturn) {
 449             ComponentFieldsEnum field = ComponentFieldsEnum.findByValue(fieldName);
 450             if (field == null) {
 451                 log.error(INVALID_INPUT_GIVEN_TO_DATA_CONVERTER, fieldName);
 452                 continue;
 453             }
 454             switch (field) {
 455                 case SERVICE_API_ARTIFACTS:
 456                     setServiceApiArtifacts(service, dataTransfer);
 457                     break;
 458                 case FORWARDING_PATHS:
 459                     setForwardingPaths(service, dataTransfer);
 460                     break;
 461                 case METADATA:
 462                     UiServiceMetadata metadata = new UiServiceMetadata(service.getCategories(),
 463                         (ServiceMetadataDataDefinition) service.getComponentMetadataDefinition()
 464                             .getMetadataDataDefinition());
 465                     dataTransfer.setMetadata(metadata);
 466                     break;
 467                 case NODE_FILTER:
 468                     if (service.getNodeFilterComponents() == null) {
 469                         dataTransfer.setNodeFilterforNode(null);
 470                     } else {
 471                         final NodeFilterConverter nodeFilterConverter = new NodeFilterConverter();
 472                         dataTransfer.setNodeFilterforNode(
 473                             nodeFilterConverter.convertDataMapToUI(service.getNodeFilterComponents()));
 474                     }
 475                     break;
 476                 case SUBSTITUTION_FILTER:
 477                     if (service.getSubstitutionFilter() == null) {
 478                         dataTransfer.setSubstitutionFilterForTopologyTemplate(null);
 479                     } else {
 480                         final SubstitutionFilterConverter substitutionFilterConverter = new SubstitutionFilterConverter();
 481                         final Map<String, UINodeFilter> filterUiMap = new HashMap<>();
 482                         filterUiMap.put(service.getUniqueId(),
 483                             substitutionFilterConverter.convertToUi(service.getSubstitutionFilter()));
 484                         dataTransfer.setSubstitutionFilterForTopologyTemplate(filterUiMap);
 485                     }
 486                     break;
 487                 default:
 488                     setUiTranferDataByFieldName(dataTransfer, service, fieldName);
 489             }
 490         }
 491         return dataTransfer;
 492     }
 493
 494     private void setServiceApiArtifacts(Service service, UiServiceDataTransfer dataTransfer) {
 495         if (service.getServiceApiArtifacts() == null) {
 496             dataTransfer.setServiceApiArtifacts(new org.openecomp.sdc.be.ui.model.SerializedHashMap<>());
 497         } else {
 498             dataTransfer.setServiceApiArtifacts(service.getServiceApiArtifacts());
 499         }
 500     }
 501
 502     private void setForwardingPaths(Service service, UiServiceDataTransfer dataTransfer) {
 503         if (service.getForwardingPaths() == null) {
 504             dataTransfer.setForwardingPaths(new org.openecomp.sdc.be.ui.model.SerializedHashMap<>());
 505         } else {
 506             dataTransfer.setForwardingPaths(service.getForwardingPaths());
 507         }
 508     }
 509
 510     public static UiComponentMetadata convertToUiComponentMetadata(Component component) {
 511
 512         UiComponentMetadata uiComponentMetadata = null;
 513         switch (component.getComponentType()) {
 514             case RESOURCE:
 515                 Resource resource = (Resource) component;
 516                 uiComponentMetadata = new UiResourceMetadata(component.getCategories(), resource.getDerivedFrom(),
 517                     (ResourceMetadataDataDefinition) resource.getComponentMetadataDefinition()
 518                         .getMetadataDataDefinition());
 519                 break;
 520             case SERVICE:
 521                 uiComponentMetadata = new UiServiceMetadata(component.getCategories(),
 522                     (ServiceMetadataDataDefinition) component.getComponentMetadataDefinition()
 523                         .getMetadataDataDefinition());
 524                 break;
 525             default:
 526                 break;
 527         }
 528         return uiComponentMetadata;
 529     }
 530 }