catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/NodeFilterConverter.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.be.tosca.utils;
  18
  19 import org.apache.commons.collections.CollectionUtils;
  20 import org.openecomp.sdc.be.datamodel.utils.ConstraintConvertor;
  21 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
  22 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterCapabilityDataDefinition;
  23 import org.openecomp.sdc.be.datatypes.elements.RequirementNodeFilterPropertyDataDefinition;
  24 import org.openecomp.sdc.be.tosca.model.CapabilityFilter;
  25 import org.openecomp.sdc.be.tosca.model.NodeFilter;
  26 import org.openecomp.sdc.be.ui.model.UIConstraint;
  27 import org.openecomp.sdc.be.ui.model.UINodeFilter;
  28
  29 import java.util.Collections;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.stream.Collectors;
  34
  35 public class NodeFilterConverter {
  36
  37
  38     public NodeFilter convertNodeFilter(CINodeFilterDataDefinition nodeFilterData) {
  39         NodeFilter retVal = new NodeFilter();
  40         if (nodeFilterData.getCapabilities() != null) {
  41             retVal.setCapabilities(convertCapabilities(nodeFilterData.getCapabilities().getListToscaDataDefinition()));
  42         }
  43         if (nodeFilterData.getProperties() != null) {
  44             retVal.setProperties(convertProperties(nodeFilterData.getProperties().getListToscaDataDefinition()));
  45         }
  46         return retVal;
  47     }
  48
  49     private List<Map<String, CapabilityFilter>> convertCapabilities(
  50             List<RequirementNodeFilterCapabilityDataDefinition> capabilities) {
  51         if (CollectionUtils.isEmpty(capabilities)) {
  52             return Collections.emptyList();
  53         }
  54         return capabilities.stream().map(this::transformCapability).collect(Collectors.toList());
  55     }
  56
  57     private Map<String, CapabilityFilter> transformCapability(
  58             RequirementNodeFilterCapabilityDataDefinition capability) {
  59         Map<String, CapabilityFilter> retVal = new HashMap<>();
  60         if (capability.getProperties() == null) {
  61             return retVal;
  62         }
  63         List<RequirementNodeFilterPropertyDataDefinition> propertyDataDefinitionList =
  64                 capability.getProperties().getListToscaDataDefinition();
  65         for (RequirementNodeFilterPropertyDataDefinition propertyDataDefinition : propertyDataDefinitionList) {
  66             retVal.put(capability.getName(), convertCapabilityProperty(propertyDataDefinition));
  67         }
  68         return retVal;
  69     }
  70
  71     private List<Map<String, List<Object>>> convertProperties(
  72             List<RequirementNodeFilterPropertyDataDefinition> properties) {
  73         if (CollectionUtils.isEmpty(properties)) {
  74             return Collections.emptyList();
  75         }
  76         return properties.stream().map(this::transformProperty).collect(Collectors.toList());
  77     }
  78
  79     private CapabilityFilter convertCapabilityProperty(RequirementNodeFilterPropertyDataDefinition property) {
  80         TransformCapabilityData transformCapabilityData = new TransformCapabilityData(property).invoke();
  81         Map<String, List<Object>> tranformedMap = transformCapabilityData.getRetVal();
  82         List<Object> constraints = transformCapabilityData.getConstraints();
  83         tranformedMap.put(property.getName(), constraints);
  84         CapabilityFilter capabilityFilter = new CapabilityFilter();
  85         capabilityFilter.setProperties(Collections.singletonList(tranformedMap));
  86         return capabilityFilter;
  87     }
  88
  89
  90     private Map<String, List<Object>> transformProperty(RequirementNodeFilterPropertyDataDefinition property) {
  91         TransformCapabilityData transformCapabilityData = new TransformCapabilityData(property).invoke();
  92         Map<String, List<Object>> retVal = transformCapabilityData.getRetVal();
  93         List<Object> constraints = transformCapabilityData.getConstraints();
  94         retVal.put(property.getName(), constraints);
  95
  96         return retVal;
  97     }
  98
  99     private class TransformCapabilityData {
 100
 101         private RequirementNodeFilterPropertyDataDefinition property;
 102         private Map<String, List<Object>> retVal;
 103         private List<Object> constraints;
 104
 105         public TransformCapabilityData(RequirementNodeFilterPropertyDataDefinition property) {
 106             this.property = property;
 107         }
 108
 109         public Map<String, List<Object>> getRetVal() {
 110             return retVal;
 111         }
 112
 113         public List<Object> getConstraints() {
 114             return constraints;
 115         }
 116
 117         public TransformCapabilityData invoke() {
 118             final List<String> propertyConstraints = property.getConstraints();
 119             if (CollectionUtils.isEmpty(propertyConstraints)) {
 120                 return this;
 121             }
 122             this.constraints = propertyConstraints.stream().map(c -> (Object) c).collect(Collectors.toList());
 123             return this;
 124         }
 125     }
 126
 127     public Map<String, UINodeFilter> convertDataMapToUI(Map<String, CINodeFilterDataDefinition> inMap) {
 128         return inMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, o -> convertToUi(o.getValue())));
 129     }
 130
 131     public UINodeFilter convertToUi(CINodeFilterDataDefinition inNodeFilter) {
 132         UINodeFilter retVal = new UINodeFilter();
 133         final ConstraintConvertor constraintConvertor = new ConstraintConvertor();
 134         if (inNodeFilter.getProperties() == null || inNodeFilter.getProperties().isEmpty()) {
 135             return retVal;
 136         }
 137         List<UIConstraint> constraints = inNodeFilter.getProperties().getListToscaDataDefinition().stream()
 138                                                      .map(property -> property.getConstraints().iterator().next())
 139                                                      .map(constraintConvertor::convert)
 140                                                      .collect(Collectors.toList());
 141         retVal.setProperties(constraints);
 142         return retVal;
 143     }
 144 }