2 * Copyright © 2016-2018 European Support Limited
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 package org.openecomp.sdc.be.model.jsontitan.utils;
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.datatypes.elements.OperationOutputDefinition;
24 import org.openecomp.sdc.be.model.InputDefinition;
25 import org.openecomp.sdc.be.model.InterfaceDefinition;
26 import org.openecomp.sdc.be.model.Operation;
27 import org.openecomp.sdc.be.model.Resource;
30 import java.util.stream.Collectors;
32 public class InterfaceUtils {
34 public static final String INTERFACE_TOSCA_RESOURCE_NAME = "org.openecomp.interfaces.node.lifecycle.%s";
36 public static final Optional<InterfaceDefinition> getInterfaceDefinitionFromToscaName(
37 Collection<InterfaceDefinition> interfaces,
38 String resourceName) {
39 if (CollectionUtils.isEmpty(interfaces)) {
40 return Optional.empty();
43 String toscaName = createInterfaceToscaResourceName(resourceName);
44 return interfaces.stream().filter(
45 interfaceDefinition -> interfaceDefinition.getToscaResourceName() != null && interfaceDefinition
46 .getToscaResourceName().equals(toscaName)).findAny();
49 public static Collection<InterfaceDefinition> getInterfaceDefinitionListFromToscaName(Collection<InterfaceDefinition> interfaces,
50 String resourceName) {
51 if(CollectionUtils.isEmpty(interfaces)){
52 return CollectionUtils.EMPTY_COLLECTION;
55 String toscaName = createInterfaceToscaResourceName(resourceName);
56 return interfaces.stream().filter(
57 interfaceDefinition -> interfaceDefinition.getToscaResourceName() != null && interfaceDefinition
58 .getToscaResourceName().equals(toscaName)).collect(Collectors.toList());
61 public static String createInterfaceToscaResourceName(String resourceName) {
62 StringBuilder sb = new StringBuilder();
63 try (Formatter formatter = new Formatter(sb)){
64 return formatter.format(INTERFACE_TOSCA_RESOURCE_NAME, resourceName).toString();
68 public static Map<String, Operation> getInterfaceOperationsFromInterfaces(
69 Map<String, InterfaceDefinition> interfaces,
70 Resource resource) throws IllegalStateException {
71 if (MapUtils.isEmpty(interfaces)) {
72 return Collections.EMPTY_MAP;
74 Optional<InterfaceDefinition> optionalInterface = getInterfaceDefinitionFromToscaName(
75 interfaces.values(), resource.getName());
76 if (!optionalInterface.isPresent()) {
77 return Collections.EMPTY_MAP;
79 InterfaceDefinition interfaceDefinition = optionalInterface.get();
80 interfaceDefinition.getOperationsMap().values().stream()
81 .forEach(operation -> createInputOutput(operation, resource.getInputs()));
84 return interfaceDefinition.getOperationsMap();
88 private static void createInputOutput(Operation operation, List<InputDefinition> inputs) throws IllegalStateException {
89 ListDataDefinition<OperationInputDefinition> inputDefinitionListDataDefinition = operation.getInputs();
90 if (inputDefinitionListDataDefinition != null) {
93 List<OperationInputDefinition> listToscaDataDefinition = inputDefinitionListDataDefinition
94 .getListToscaDataDefinition();
95 List<OperationInputDefinition> convertedInputs = listToscaDataDefinition.stream()
96 .map(input -> convertInput(input, inputs))
97 .collect(Collectors.toList());
99 ListDataDefinition<OperationOutputDefinition> outputDefinitionListDataDefinition = operation.getOutputs();
100 if (outputDefinitionListDataDefinition != null) {
103 List<OperationOutputDefinition> outListToscaDefinition = outputDefinitionListDataDefinition
104 .getListToscaDataDefinition();
105 List<OperationOutputDefinition> convertedOutputs = outListToscaDefinition.stream()
106 .map(operationOutputDefinition -> convertOutput(operationOutputDefinition, inputs) )
107 .collect(Collectors.toList());
108 inputDefinitionListDataDefinition.getListToscaDataDefinition().clear();
109 inputDefinitionListDataDefinition.getListToscaDataDefinition().addAll(convertedInputs);
110 outputDefinitionListDataDefinition.getListToscaDataDefinition().clear();
111 outputDefinitionListDataDefinition.getListToscaDataDefinition().addAll(convertedOutputs);
114 private static OperationInputDefinition convertInput(OperationInputDefinition input,
115 List<InputDefinition> inputs) throws IllegalStateException {
116 Optional<InputDefinition> anyInputDefinition = inputs.stream()
117 .filter(inp -> inp.getUniqueId().equals(input.getUniqueId())).findAny();
118 if (anyInputDefinition.isPresent()) {
119 return new OperationInputDefinition(input.getLabel(),new InputDataDefinition(anyInputDefinition.get()));
121 throw new IllegalStateException("Could not find input :"+ input.getLabel());
124 private static OperationOutputDefinition convertOutput(OperationOutputDefinition output,
125 List<InputDefinition> outputs) throws IllegalStateException {
126 Optional<InputDefinition> anyOutputDefinition = outputs.stream()
127 .filter(inp -> inp.getUniqueId().equals(output.getUniqueId())).findAny();
128 if (anyOutputDefinition.isPresent()) {
129 return new OperationOutputDefinition(output.getLabel(),new InputDataDefinition(anyOutputDefinition.get()));
131 throw new IllegalStateException("Could not find output :"+ output.getLabel());
133 public static List<Operation> getOperationsFromInterface(Map<String, InterfaceDefinition> interfaces) {
134 List<Operation> operationData = new ArrayList<>();
135 if (!MapUtils.isEmpty(interfaces)) {
136 operationData = interfaces.values().stream()
137 .filter(a -> MapUtils.isNotEmpty(a.getOperationsMap()))
138 .map(a-> new ArrayList<>(a.getOperationsMap().values())).flatMap(List::stream).collect(Collectors.toList());
140 return operationData;