catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtils.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.model.jsontitan.utils;
  17
  18 import org.apache.commons.collections.CollectionUtils;
  19 import org.apache.commons.collections.MapUtils;
  20 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
  21 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  22 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
  23 import org.openecomp.sdc.be.model.InputDefinition;
  24 import org.openecomp.sdc.be.model.InterfaceDefinition;
  25 import org.openecomp.sdc.be.model.Operation;
  26 import org.openecomp.sdc.be.model.Resource;
  27
  28 import java.util.ArrayList;
  29 import java.util.Collection;
  30 import java.util.Collections;
  31 import java.util.Formatter;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Optional;
  35 import java.util.stream.Collectors;
  36
  37 public class InterfaceUtils {
  38
  39     public static final String INTERFACE_TOSCA_RESOURCE_NAME = "org.openecomp.interfaces.node.lifecycle.%s";
  40
  41     public static final Optional<InterfaceDefinition> getInterfaceDefinitionFromToscaName(
  42         Collection<InterfaceDefinition> interfaces,
  43         String resourceName) {
  44         if (CollectionUtils.isEmpty(interfaces)) {
  45             return Optional.empty();
  46         }
  47
  48         String toscaName = createInterfaceToscaResourceName(resourceName);
  49         return interfaces.stream().filter(
  50             interfaceDefinition -> interfaceDefinition.getToscaResourceName() != null && interfaceDefinition
  51                 .getToscaResourceName().equals(toscaName)).findAny();
  52     }
  53
  54     public static Collection<InterfaceDefinition> getInterfaceDefinitionListFromToscaName(Collection<InterfaceDefinition> interfaces,
  55                                                                                           String resourceName) {
  56         if(CollectionUtils.isEmpty(interfaces)){
  57             return CollectionUtils.EMPTY_COLLECTION;
  58         }
  59
  60         String toscaName = createInterfaceToscaResourceName(resourceName);
  61         return interfaces.stream().filter(
  62                 interfaceDefinition -> interfaceDefinition.getToscaResourceName() != null && interfaceDefinition
  63                         .getToscaResourceName().equals(toscaName)).collect(Collectors.toList());
  64     }
  65
  66     public static String createInterfaceToscaResourceName(String resourceName) {
  67         StringBuilder sb = new StringBuilder();
  68         Formatter formatter = new Formatter(sb);
  69         return formatter.format(INTERFACE_TOSCA_RESOURCE_NAME, resourceName).toString();
  70     }
  71
  72     public static Map<String, Operation> getInterfaceOperationsFromInterfaces(
  73         Map<String, InterfaceDefinition> interfaces,
  74         Resource resource) throws IllegalStateException {
  75         if (MapUtils.isEmpty(interfaces)) {
  76             return Collections.EMPTY_MAP;
  77         }
  78         Optional<InterfaceDefinition> optionalInterface = getInterfaceDefinitionFromToscaName(
  79             interfaces.values(), resource.getName());
  80         if (!optionalInterface.isPresent()) {
  81             return Collections.EMPTY_MAP;
  82         }
  83         InterfaceDefinition interfaceDefinition = optionalInterface.get();
  84         interfaceDefinition.getOperationsMap().values().stream()
  85             .forEach(operation -> createInput(operation, resource.getInputs()));
  86         return interfaceDefinition.getOperationsMap();
  87
  88     }
  89
  90     private static void createInput(Operation operation, List<InputDefinition> inputs) throws IllegalStateException {
  91         ListDataDefinition<OperationInputDefinition> inputDefinitionListDataDefinition = operation.getInputs();
  92         if (inputDefinitionListDataDefinition != null) {
  93             return;
  94         }
  95         List<OperationInputDefinition> listToscaDataDefinition = inputDefinitionListDataDefinition
  96             .getListToscaDataDefinition();
  97         List<OperationInputDefinition> convertedInputs = listToscaDataDefinition.stream()
  98             .map(input -> convertInput(input, inputs))
  99             .collect(Collectors.toList());
 100         inputDefinitionListDataDefinition.getListToscaDataDefinition().clear();
 101         inputDefinitionListDataDefinition.getListToscaDataDefinition().addAll(convertedInputs);
 102     }
 103
 104     private static OperationInputDefinition convertInput(OperationInputDefinition input,
 105                                                          List<InputDefinition> inputs) throws IllegalStateException {
 106         Optional<InputDefinition> anyInputDefinition = inputs.stream()
 107             .filter(inp -> inp.getUniqueId().equals(input.getUniqueId())).findAny();
 108         if (anyInputDefinition.isPresent()) {
 109             return new OperationInputDefinition(input.getLabel(),new InputDataDefinition(anyInputDefinition.get()));
 110         }
 111         throw new IllegalStateException("Could not find input :"+ input.getLabel());
 112     }
 113
 114     public static List<Operation> getOperationsFromInterface(Map<String, InterfaceDefinition> interfaces) {
 115         List<Operation> operationData = new ArrayList<>();
 116         if (!MapUtils.isEmpty(interfaces)) {
 117             operationData = interfaces.values().stream()
 118                 .filter(a -> MapUtils.isNotEmpty(a.getOperationsMap()))
 119                 .map(a-> new ArrayList<>(a.getOperationsMap().values())).flatMap(List::stream).collect(Collectors.toList());
 120         }
 121         return operationData;
 122     }
 123 }