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