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