sonar issue fix

[sdc.git] / catalog-model / src / main / java / org / openecomp / sdc / be / model / jsontitan / utils / InterfaceUtils.java

diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtils.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtils.java
index a350d7e..a3ec3f2 100644 (file)
--- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtils.java
+++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/jsontitan/utils/InterfaceUtils.java
@@ -15,8 +15,12 @@
  */
 package org.openecomp.sdc.be.model.jsontitan.utils;
 
+import java.util.Collection;
+import java.util.Formatter;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
 import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.collections.MapUtils;
 import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
@@ -24,10 +28,6 @@ import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.Operation;
-import org.openecomp.sdc.be.model.Resource;
-
-import java.util.*;
-import java.util.stream.Collectors;
 
 public class InterfaceUtils {
 
@@ -47,52 +47,31 @@ public class InterfaceUtils {
     }
 
     public static Collection<InterfaceDefinition> getInterfaceDefinitionListFromToscaName(Collection<InterfaceDefinition> interfaces,
-                                                                                          String resourceName) {
+        String resourceName) {
         if(CollectionUtils.isEmpty(interfaces)){
             return CollectionUtils.EMPTY_COLLECTION;
         }
 
         String toscaName = createInterfaceToscaResourceName(resourceName);
         return interfaces.stream().filter(
-                interfaceDefinition -> interfaceDefinition.getToscaResourceName() != null && interfaceDefinition
-                        .getToscaResourceName().equals(toscaName)).collect(Collectors.toList());
+            interfaceDefinition -> interfaceDefinition.getToscaResourceName() != null && interfaceDefinition
+                .getToscaResourceName().equals(toscaName)).collect(Collectors.toList());
     }
 
     public static String createInterfaceToscaResourceName(String resourceName) {
         StringBuilder sb = new StringBuilder();
-        try (Formatter formatter = new Formatter(sb)){
+        try(Formatter formatter = new Formatter(sb)){
             return formatter.format(INTERFACE_TOSCA_RESOURCE_NAME, resourceName).toString();
         }
     }
 
-    public static Map<String, Operation> getInterfaceOperationsFromInterfaces(
-        Map<String, InterfaceDefinition> interfaces,
-        Resource resource) throws IllegalStateException {
-        if (MapUtils.isEmpty(interfaces)) {
-            return Collections.EMPTY_MAP;
-        }
-        Optional<InterfaceDefinition> optionalInterface = getInterfaceDefinitionFromToscaName(
-            interfaces.values(), resource.getName());
-        if (!optionalInterface.isPresent()) {
-            return Collections.EMPTY_MAP;
-        }
-        InterfaceDefinition interfaceDefinition = optionalInterface.get();
-        interfaceDefinition.getOperationsMap().values().stream()
-            .forEach(operation -> createInputOutput(operation, resource.getInputs()));
-
-
-        return interfaceDefinition.getOperationsMap();
-
-    }
-
-    private static void createInputOutput(Operation operation, List<InputDefinition> inputs) throws IllegalStateException {
+    public static void createInputOutput(Operation operation, List<InputDefinition> inputs, List<InputDefinition> outputs) throws IllegalStateException {
         ListDataDefinition<OperationInputDefinition> inputDefinitionListDataDefinition = operation.getInputs();
         if (inputDefinitionListDataDefinition != null) {
             return;
         }
-        List<OperationInputDefinition> listToscaDataDefinition = inputDefinitionListDataDefinition
-            .getListToscaDataDefinition();
-        List<OperationInputDefinition> convertedInputs = listToscaDataDefinition.stream()
+        List<OperationInputDefinition> inputListToscaDataDefinition = inputDefinitionListDataDefinition.getListToscaDataDefinition();
+        List<OperationInputDefinition> convertedInputs = inputListToscaDataDefinition.stream()
             .map(input -> convertInput(input, inputs))
             .collect(Collectors.toList());
 
@@ -100,11 +79,11 @@ public class InterfaceUtils {
         if (outputDefinitionListDataDefinition != null) {
             return;
         }
-        List<OperationOutputDefinition> outListToscaDefinition = outputDefinitionListDataDefinition
-                .getListToscaDataDefinition();
-        List<OperationOutputDefinition> convertedOutputs = outListToscaDefinition.stream()
-                .map(operationOutputDefinition -> convertOutput(operationOutputDefinition, inputs) )
-                .collect(Collectors.toList());
+        List<OperationOutputDefinition> outputListToscaDataDefinition = outputDefinitionListDataDefinition.getListToscaDataDefinition();
+        List<OperationOutputDefinition> convertedOutputs = outputListToscaDataDefinition.stream()
+            .map(output -> convertOutput(output, outputs) )
+            .collect(Collectors.toList());
+
         inputDefinitionListDataDefinition.getListToscaDataDefinition().clear();
         inputDefinitionListDataDefinition.getListToscaDataDefinition().addAll(convertedInputs);
         outputDefinitionListDataDefinition.getListToscaDataDefinition().clear();
@@ -112,7 +91,7 @@ public class InterfaceUtils {
     }
 
     private static OperationInputDefinition convertInput(OperationInputDefinition input,
-                                                         List<InputDefinition> inputs) throws IllegalStateException {
+        List<InputDefinition> inputs) throws IllegalStateException {
         Optional<InputDefinition> anyInputDefinition = inputs.stream()
             .filter(inp -> inp.getUniqueId().equals(input.getUniqueId())).findAny();
         if (anyInputDefinition.isPresent()) {
@@ -122,21 +101,13 @@ public class InterfaceUtils {
     }
 
     private static OperationOutputDefinition convertOutput(OperationOutputDefinition output,
-                                                         List<InputDefinition> outputs) throws IllegalStateException {
+        List<InputDefinition> outputs) throws IllegalStateException {
         Optional<InputDefinition> anyOutputDefinition = outputs.stream()
-                .filter(inp -> inp.getUniqueId().equals(output.getUniqueId())).findAny();
+            .filter(op -> op.getUniqueId().equals(output.getUniqueId())).findAny();
         if (anyOutputDefinition.isPresent()) {
             return new OperationOutputDefinition(output.getLabel(),new InputDataDefinition(anyOutputDefinition.get()));
         }
         throw new IllegalStateException("Could not find output :"+ output.getLabel());
     }
-    public static List<Operation> getOperationsFromInterface(Map<String, InterfaceDefinition> interfaces) {
-        List<Operation> operationData = new ArrayList<>();
-        if (!MapUtils.isEmpty(interfaces)) {
-            operationData = interfaces.values().stream()
-                .filter(a -> MapUtils.isNotEmpty(a.getOperationsMap()))
-                .map(a-> new ArrayList<>(a.getOperationsMap().values())).flatMap(List::stream).collect(Collectors.toList());
-        }
-        return operationData;
-    }
+
 }