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