catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/NodeFilterUploadCreator.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.components.impl;
  18
  19 import org.onap.sdc.tosca.services.YamlUtil;
  20 import org.openecomp.sdc.be.model.UploadNodeFilterCapabilitiesInfo;
  21 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
  22 import org.openecomp.sdc.be.model.UploadNodeFilterPropertyInfo;
  23 import org.openecomp.sdc.be.utils.TypeUtils;
  24
  25 import java.util.ArrayList;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.stream.Collectors;
  30
  31 public class NodeFilterUploadCreator {
  32
  33     public UploadNodeFilterInfo createNodeFilterData(Object obj) {
  34         if (!(obj instanceof Map)) {
  35             return null;
  36         }
  37         Map<String, Object> nodeFilterMap = (Map<String, Object>) obj;
  38
  39         UploadNodeFilterInfo uploadNodeFilterInfo = new UploadNodeFilterInfo();
  40         final String propertiesElementName = TypeUtils.ToscaTagNamesEnum.PROPERTIES.getElementName();
  41         if (nodeFilterMap.containsKey(propertiesElementName)) {
  42             uploadNodeFilterInfo.setProperties(createNodeFilterProperties(nodeFilterMap.get(propertiesElementName)));
  43         }
  44         final String capabilitiesElementName = TypeUtils.ToscaTagNamesEnum.CAPABILITIES.getElementName();
  45         if (nodeFilterMap.containsKey(capabilitiesElementName)) {
  46             uploadNodeFilterInfo
  47                     .setCapabilities(createNodeFilterCapabilities(nodeFilterMap.get(capabilitiesElementName)));
  48         }
  49         final String toscaId = TypeUtils.ToscaTagNamesEnum.TOSCA_ID.getElementName();
  50         if (nodeFilterMap.containsKey(toscaId)) {
  51             uploadNodeFilterInfo.setTosca_id(nodeFilterMap.get(toscaId));
  52         }
  53         return uploadNodeFilterInfo;
  54     }
  55
  56     private List<UploadNodeFilterPropertyInfo> createNodeFilterProperties(Object o) {
  57         if (!(o instanceof List)) {
  58             return null;
  59         }
  60         List<UploadNodeFilterPropertyInfo> retVal = new ArrayList<>();
  61         List<Map<String, Object>> propertiesList = (List<Map<String, Object>>) o;
  62         for (Map<String, Object> map : propertiesList) {
  63             final Map.Entry<String, Object> entry = map.entrySet().iterator().next();
  64             final Object value = entry.getValue();
  65             if (value instanceof Map) {
  66                 List<String> valueList = new ArrayList<>();
  67                 valueList.add(valueToProperty(entry.getValue()));
  68                 retVal.add(new UploadNodeFilterPropertyInfo(entry.getKey(), valueList));
  69             } else if (value instanceof List) {
  70                 List<String> propertiesVals =
  71                         (List<String>) ((List) value).stream().map(this::valueToProperty).collect(Collectors.toList());
  72                 retVal.add(new UploadNodeFilterPropertyInfo(entry.getKey(), propertiesVals));
  73             }
  74         }
  75         return retVal;
  76     }
  77
  78     private String valueToProperty(Object o) {
  79
  80         if (o instanceof Map) {
  81             return new YamlUtil().objectToYaml(o);
  82         }
  83         return null;
  84     }
  85
  86     private Map<String, UploadNodeFilterCapabilitiesInfo> createNodeFilterCapabilities(Object o) {
  87         if (!(o instanceof List)) {
  88             return null;
  89         }
  90         Map<String, UploadNodeFilterCapabilitiesInfo> retVal = new HashMap<>();
  91         List<Map<String, Object>> capabilitiesMap = (List<Map<String, Object>>) o;
  92         for (Map<String, Object> map : capabilitiesMap) {
  93             final Map.Entry<String, Object> entry = map.entrySet().iterator().next();
  94             UploadNodeFilterCapabilitiesInfo uploadNodeFilterCapabilitiesInfo = new UploadNodeFilterCapabilitiesInfo();
  95             uploadNodeFilterCapabilitiesInfo.setName(entry.getKey());
  96             uploadNodeFilterCapabilitiesInfo.setProperties(createCapabilitiesProperties(entry.getValue()));
  97             retVal.put(entry.getKey(), uploadNodeFilterCapabilitiesInfo);
  98         }
  99         return retVal;
 100
 101     }
 102
 103     private List<UploadNodeFilterPropertyInfo> createCapabilitiesProperties(Object o) {
 104         if (!(o instanceof Map)) {
 105             return null;
 106         }
 107         Map<String, Object> capabilitiesPropertiesMap = (Map<String, Object>) o;
 108         final String capabilitiesPropertiesElementName = TypeUtils.ToscaTagNamesEnum.PROPERTIES.getElementName();
 109         if (capabilitiesPropertiesMap.containsKey(capabilitiesPropertiesElementName)) {
 110             final Object propertiesObject = capabilitiesPropertiesMap.get(capabilitiesPropertiesElementName);
 111             return createNodeFilterProperties(propertiesObject);
 112         }
 113         return null;
 114     }
 115
 116
 117 }