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