Support interface input during import VFC

Change-Id: I097ce258a7dadbedf1aff6ce53dd1286da074552
Issue-ID: SDC-3372
Signed-off-by: andre.schmid <andre.schmid@est.tech>

5 files changed, 369 insertions, 243 deletions

diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java
index 4127faa820..614b261b4a 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ImportUtils.java
@@ -47,6 +47,7 @@ import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentEx
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.datatypes.elements.Annotation;
+import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
@@ -348,24 +349,24 @@ public final class ImportUtils {
         }
     }
 
-    private static List<PropertyConstraint> getPropertyConstraints(Map<String, Object> propertyValue,
-                                                                   String propertyType) {
-        List<Object> propertyFieldConstraints = findCurrentLevelConstraintsElement(propertyValue);
-        if (CollectionUtils.isNotEmpty(propertyFieldConstraints)) {
-            List<PropertyConstraint> constraintList = new ArrayList<>();
-            Type constraintType = new TypeToken<PropertyConstraint>() {
-            }.getType();
-            Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyConstraintDeserialiser())
-                .create();
+    private static List<PropertyConstraint> getPropertyConstraints(final Map<String, Object> propertyValue,
+                                                                   final String propertyType) {
+        final List<Object> propertyFieldConstraints = findCurrentLevelConstraintsElement(propertyValue);
+        if (CollectionUtils.isEmpty(propertyFieldConstraints)) {
+            return Collections.emptyList();
+        }
+        final List<PropertyConstraint> constraintList = new ArrayList<>();
+        final Type constraintType = new TypeToken<PropertyConstraint>() {
+        }.getType();
+        final Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyConstraintDeserialiser())
+            .create();
 
-            for (Object constraintJson : propertyFieldConstraints) {
-                PropertyConstraint propertyConstraint = validateAndGetPropertyConstraint(propertyType, constraintType,
-                    gson, constraintJson);
-                constraintList.add(propertyConstraint);
-            }
-            return constraintList;
+        for (final Object constraintJson : propertyFieldConstraints) {
+            final PropertyConstraint propertyConstraint = validateAndGetPropertyConstraint(propertyType, constraintType,
+                gson, constraintJson);
+            constraintList.add(propertyConstraint);
         }
-        return null;
+        return constraintList;
     }
 
     private static List<Object> findCurrentLevelConstraintsElement(Map<String, Object> toscaJson) {
@@ -485,10 +486,13 @@ public final class ImportUtils {
         return result;
     }
 
-    public static InputDefinition createModuleInput(Map<String, Object> inputValue,
-                                                    AnnotationTypeOperations annotationTypeOperations) {
+    public static InputDefinition createModuleInput(final Map<String, Object> inputValue,
+                                                    final AnnotationTypeOperations annotationTypeOperations) {
+        return parseAnnotationsAndAddItToInput(createModuleInput(inputValue), inputValue, annotationTypeOperations);
+    }
 
-        InputDefinition inputDef = new InputDefinition();
+    public static InputDefinition createModuleInput(final Map<String, Object> inputValue) {
+        final InputDefinition inputDef = new InputDefinition();
         setField(inputValue, TypeUtils.ToscaTagNamesEnum.TYPE, inputDef::setType);
         setFieldBoolean(inputValue, ToscaTagNamesEnum.REQUIRED, req -> inputDef.setRequired(Boolean.parseBoolean(req)));
         setField(inputValue, TypeUtils.ToscaTagNamesEnum.DESCRIPTION, inputDef::setDescription);
@@ -504,9 +508,7 @@ public final class ImportUtils {
 
         setScheme(inputValue, inputDef);
         setPropertyConstraints(inputValue, inputDef);
-
-        return parseAnnotationsAndAddItToInput(inputDef, inputValue, annotationTypeOperations);
-
+        return inputDef;
     }
 
     public static InputDefinition parseAnnotationsAndAddItToInput(InputDefinition inputDef,
@@ -608,6 +610,11 @@ public final class ImportUtils {
 
     }
 
+    public static Either<Map<String, InputDefinition>, ResultStatusEnum> getInputs(final Map<String, Object> toscaJson) {
+        return getElements(toscaJson, TypeUtils.ToscaTagNamesEnum.INPUTS, ImportUtils::createInputs,
+            ImportUtils::createModuleInput);
+    }
+
     public static <T> Either<Map<String, T>, ResultStatusEnum> getElements(Map<String, Object> toscaJson,
                                                                            TypeUtils.ToscaTagNamesEnum elementTagName,
                                                                            Function<String, T> elementGenByName,
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java
new file mode 100644
index 0000000000..aeb4376c15
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceDefinitionHandler.java
@@ -0,0 +1,255 @@
+/*
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2020 Nordix Foundation
+ *  ================================================================================
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *  SPDX-License-Identifier: Apache-2.0
+ *  ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.components.impl;
+
+import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.IMPLEMENTATION;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NOTIFICATIONS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.STATUS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
+
+import fj.data.Either;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.apache.commons.collections.MapUtils;
+import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
+import org.openecomp.sdc.exception.ResponseFormat;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+/**
+ * Handles interface definition TOSCA conversions
+ */
+@Component("interfaceDefinitionHandler")
+public class InterfaceDefinitionHandler {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceDefinitionHandler.class);
+
+    private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
+
+    public InterfaceDefinitionHandler(final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
+        this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
+    }
+
+    /**
+     * Creates an interface definition based on a TOSCA map representing an interface definition.
+     *
+     * @param interfaceDefinitionToscaMap the TOSCA interface definition structure
+     * @return an interface definition representation
+     */
+    public InterfaceDefinition create(final Map<String, Object> interfaceDefinitionToscaMap) {
+
+        final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+
+        if (interfaceDefinitionToscaMap.containsKey(TYPE.getElementName())) {
+            final Object typeObj = interfaceDefinitionToscaMap.get(TYPE.getElementName());
+            if (!(typeObj instanceof String)) {
+                throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
+            }
+            final String type = (String) typeObj;
+            interfaceDefinition.setType(type);
+            interfaceDefinition.setUniqueId(type.toLowerCase());
+        }
+
+        final Map<String, InputDefinition> inputDefinitionMap = handleInputs(interfaceDefinitionToscaMap);
+        if (!inputDefinitionMap.isEmpty()) {
+            final Map<String, InputDataDefinition> collect = inputDefinitionMap.entrySet().stream().
+                collect(Collectors.toMap(Entry::getKey, value -> new InputDataDefinition(value.getValue())));
+            interfaceDefinition.setInputs(collect);
+        }
+        final Map<String, OperationDataDefinition> operationMap;
+        if (interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName()) || interfaceDefinitionToscaMap
+            .containsKey(NOTIFICATIONS.getElementName())) {
+            operationMap = handleOperations(interfaceDefinitionToscaMap);
+            //TODO handle notifications
+        } else {
+            operationMap = handleLegacyOperations(interfaceDefinitionToscaMap);
+        }
+        if (!operationMap.isEmpty()) {
+            validateOperations(interfaceDefinition.getType(), operationMap);
+            interfaceDefinition.setOperations(operationMap);
+        }
+
+        return interfaceDefinition;
+    }
+
+    private void validateOperations(final String interfaceType,
+                                    final Map<String, OperationDataDefinition> operationMap) {
+        if (MapUtils.isEmpty(operationMap)) {
+            return;
+        }
+        Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceDefinitionMapEither =
+            interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes();
+        if (interfaceDefinitionMapEither.isRight() || MapUtils.isEmpty(interfaceDefinitionMapEither.left().value())) {
+            throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
+        }
+
+        final Map<String, InterfaceDefinition> interfaceDefinitionMap = interfaceDefinitionMapEither.left().value();
+        final Optional<InterfaceDefinition> interfaceDefinitionOptional = interfaceDefinitionMap.entrySet().stream()
+            .filter(interfaceDefinitionEntry -> interfaceDefinitionEntry.getKey().equalsIgnoreCase(interfaceType))
+            .map(Entry::getValue).findFirst();
+        if (interfaceDefinitionOptional.isEmpty()) {
+            throw new ByActionStatusComponentException(ActionStatus.INTERFACE_UNKNOWN, interfaceType);
+        }
+        final InterfaceDefinition interfaceDefinition = interfaceDefinitionOptional.get();
+        operationMap.keySet().forEach(operation1 -> {
+            if (!interfaceDefinition.hasOperation(operation1)) {
+                throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_DEFINED,
+                    operation1, interfaceType);
+            }
+        });
+    }
+
+    private Map<String, OperationDataDefinition> handleOperations(
+        final Map<String, Object> interfaceDefinitionToscaMap) {
+        if (!interfaceDefinitionToscaMap.containsKey(OPERATIONS.getElementName())) {
+            return Collections.emptyMap();
+        }
+        final Map<String, Object> operationMap =
+            (Map<String, Object>) interfaceDefinitionToscaMap.get(OPERATIONS.getElementName());
+        return operationMap.entrySet().stream()
+            .map(interfaceEntry -> createOperation(interfaceEntry.getKey(),
+                (Map<String, Object>) interfaceEntry.getValue()))
+            .collect(
+                Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
+    }
+
+    private Map<String, OperationDataDefinition> handleLegacyOperations(
+        final Map<String, Object> interfaceDefinitionToscaMap) {
+        final List<String> notALegacyOperationEntry = Arrays
+            .asList(OPERATIONS.getElementName(),
+                TYPE.getElementName(),
+                INPUTS.getElementName(),
+                NOTIFICATIONS.getElementName());
+        return interfaceDefinitionToscaMap.entrySet().stream()
+            .filter(interfaceEntry -> !notALegacyOperationEntry.contains(interfaceEntry.getKey()))
+            .map(interfaceEntry -> createOperation(interfaceEntry.getKey(),
+                (Map<String, Object>) interfaceEntry.getValue()))
+            .collect(
+                Collectors.toMap(OperationDataDefinition::getName, operationDataDefinition -> operationDataDefinition));
+    }
+
+
+    private OperationDataDefinition createOperation(final String operationName,
+                                                    final Map<String, Object> operationDefinitionMap) {
+        final OperationDataDefinition operation = new OperationDataDefinition();
+        operation.setName(operationName);
+
+        handleOperationImplementation(operationDefinitionMap).ifPresent(operation::setImplementation);
+        if (operationDefinitionMap.containsKey(INPUTS.getElementName())) {
+            final Map<String, Object> interfaceInputs =
+                (Map<String, Object>) operationDefinitionMap.get(INPUTS.getElementName());
+            operation.setInputs(handleInterfaceOperationInputs(interfaceInputs));
+        }
+
+        return operation;
+    }
+
+    private ListDataDefinition<OperationInputDefinition> handleInterfaceOperationInputs(
+        final Map<String, Object> interfaceInputs) {
+        final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
+        for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
+            final OperationInputDefinition operationInput = new OperationInputDefinition();
+            operationInput.setName(interfaceInput.getKey());
+            if (interfaceInput.getValue() instanceof Map) {
+                final LinkedHashMap<String, Object> inputPropertyValue =
+                    (LinkedHashMap<String, Object>) interfaceInput.getValue();
+                LOGGER.info("createModuleInterface: i interfaceInput.getKey() {}, {} , {}  ",
+                    interfaceInput.getKey(), inputPropertyValue.keySet(), inputPropertyValue.values());
+                if (inputPropertyValue.get(TYPE.getElementName()) != null) {
+                    operationInput.setType(inputPropertyValue.get(TYPE.getElementName()).toString());
+                }
+                if (inputPropertyValue.get(DESCRIPTION.getElementName()) != null) {
+                    operationInput.setDescription(inputPropertyValue.get(DESCRIPTION.getElementName()).toString());
+                }
+                if (inputPropertyValue.get(REQUIRED.getElementName()) != null) {
+                    operationInput.setRequired(
+                        Boolean.getBoolean(inputPropertyValue.get(REQUIRED.getElementName()).toString()));
+                }
+                if (inputPropertyValue.get(DEFAULT.getElementName()) != null) {
+                    operationInput.setToscaDefaultValue(inputPropertyValue.get(DEFAULT.getElementName()).toString());
+                }
+                if (inputPropertyValue.get(STATUS.getElementName()) != null) {
+                    operationInput.setStatus(inputPropertyValue.get(STATUS.getElementName()).toString());
+                }
+
+            } else if (interfaceInput.getValue() instanceof String) {
+                final String value = (String) interfaceInput.getValue();
+                operationInput.setDefaultValue(value);
+                operationInput.setToscaDefaultValue(value);
+                operationInput.setValue(value);
+            }
+            inputs.add(operationInput);
+        }
+        return inputs;
+    }
+
+    private Optional<ArtifactDataDefinition> handleOperationImplementation(
+        final Map<String, Object> operationDefinitionMap) {
+        if (!operationDefinitionMap.containsKey(IMPLEMENTATION.getElementName())) {
+            return Optional.empty();
+        }
+        final ArtifactDataDefinition artifactDataDefinition = new ArtifactDataDefinition();
+        final String artifactName = (String) operationDefinitionMap.get(IMPLEMENTATION.getElementName());
+        if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) {
+            artifactDataDefinition.setArtifactName(artifactName);
+        } else {
+            artifactDataDefinition.setArtifactName(QUOTE + artifactName + QUOTE);
+        }
+        return Optional.of(artifactDataDefinition);
+    }
+
+    private Map<String, InputDefinition> handleInputs(final Map<String, Object> interfaceDefinitionToscaMap) {
+        if (!interfaceDefinitionToscaMap.containsKey(INPUTS.getElementName())) {
+            return Collections.emptyMap();
+        }
+
+        final Either<Map<String, InputDefinition>, ResultStatusEnum> inputMapEither =
+            ImportUtils.getInputs(interfaceDefinitionToscaMap);
+        if (inputMapEither.isRight()) {
+            return Collections.emptyMap();
+        }
+
+        return inputMapEither.left().value();
+    }
+
+}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java
index 7ff916df32..b96e4e58e2 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceImportManager.java
@@ -22,7 +22,6 @@
 
 package org.openecomp.sdc.be.components.impl;
 
-import static org.openecomp.sdc.be.components.impl.ImportUtils.Constants.QUOTE;
 import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementOperation.createDataType;
 import static org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaElementOperation.createDataTypeDefinitionWithName;
 import static org.openecomp.sdc.be.utils.TypeUtils.setField;
@@ -34,7 +33,6 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -62,11 +60,7 @@ import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
-import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
-import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
@@ -94,7 +88,6 @@ import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
-import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
 import org.openecomp.sdc.be.utils.TypeUtils;
 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
 import org.openecomp.sdc.common.log.wrappers.Logger;
@@ -112,13 +105,7 @@ public class ResourceImportManager {
     private static final Logger log = Logger.getLogger(ResourceImportManager.class);
 
     static final Pattern PROPERTY_NAME_PATTERN_IGNORE_LENGTH = Pattern.compile("[\\w\\-\\_\\d\\:]+");
-    private static final String IMPLEMENTATION = "implementation";
-    private static final String INPUTS = "inputs";
-    private static final String TYPE = "type";
-    private static final String DESCRIPTION = "description";
-    private static final String REQUIRED = "required";
-    private static final String DEFAULT = "default";
-    private static final String STATUS = "status";
+    private final InterfaceDefinitionHandler interfaceDefinitionHandler;
 
     private ServletContext servletContext;
 
@@ -134,7 +121,6 @@ public class ResourceImportManager {
 
     @Autowired
     private ServiceBusinessLogic serviceBusinessLogic;
-    private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
 
     private IGraphLockOperation graphLockOperation;
     private ToscaOperationFacade toscaOperationFacade;
@@ -145,9 +131,11 @@ public class ResourceImportManager {
     private ResponseFormatManager responseFormatManager;
 
     @Autowired
-    public ResourceImportManager(ComponentsUtils componentsUtils, CapabilityTypeOperation capabilityTypeOperation) {
+    public ResourceImportManager(ComponentsUtils componentsUtils, CapabilityTypeOperation capabilityTypeOperation,
+                                 final InterfaceDefinitionHandler interfaceDefinitionHandler) {
         this.componentsUtils = componentsUtils;
         this.capabilityTypeOperation = capabilityTypeOperation;
+        this.interfaceDefinitionHandler = interfaceDefinitionHandler;
     }
 
     @Autowired
@@ -380,11 +368,9 @@ public class ResourceImportManager {
         if (toscaInterfaces.isLeft()) {
             Map<String, Object> jsonInterfaces = toscaInterfaces.left().value();
             Map<String, InterfaceDefinition> moduleInterfaces = new HashMap<>();
-            Iterator<Entry<String, Object>> interfacesNameValue = jsonInterfaces.entrySet().iterator();
-            while (interfacesNameValue.hasNext()) {
-                Entry<String, Object> interfaceNameValue = interfacesNameValue.next();
-                Either<InterfaceDefinition, ResultStatusEnum> eitherInterface = createModuleInterface(interfaceNameValue
-                    .getValue(), resource);
+            for (final Entry<String, Object> interfaceNameValue : jsonInterfaces.entrySet()) {
+                final Either<InterfaceDefinition, ResultStatusEnum> eitherInterface =
+                    createModuleInterface(interfaceNameValue.getValue());
                 if (eitherInterface.isRight()) {
                     log.info("error when creating interface:{}, for resource:{}", interfaceNameValue.getKey(),
                         resource.getName());
@@ -393,165 +379,32 @@ public class ResourceImportManager {
                 }
 
             }
-            if (moduleInterfaces.size() > 0) {
+            if (!moduleInterfaces.isEmpty()) {
                 resource.setInterfaces(moduleInterfaces);
             }
         }
     }
 
-    private Either<InterfaceDefinition, ResultStatusEnum> createModuleInterface(Object interfaceJson,
-                                                                                Resource resource) {
-        final InterfaceDefinition interf = new InterfaceDefinition();
-        Either<InterfaceDefinition, ResultStatusEnum> result = Either.left(interf);
-
+    private Either<InterfaceDefinition, ResultStatusEnum> createModuleInterface(final Object interfaceJson) {
         try {
             if (interfaceJson instanceof String) {
-                final String requirementJsonString = (String) interfaceJson;
-                interf.setType(requirementJsonString);
-            } else if (interfaceJson instanceof Map && ResourceTypeEnum.VFC.equals(resource.getResourceType())) {
-                final Map<String, Object> requirementJsonMap = (Map<String, Object>) interfaceJson;
-                final Map<String, OperationDataDefinition> operations = new HashMap<>();
-
-                for (final Entry<String, Object> entry : requirementJsonMap.entrySet()) {
-                    if (entryIsInterfaceType(entry)) {
-                        final String type = (String) requirementJsonMap
-                            .get(TypeUtils.ToscaTagNamesEnum.TYPE.getElementName());
-                        interf.setType(type);
-                        interf.setUniqueId(type.toLowerCase());
-                    } else if (entryContainsImplementationForAKnownOperation(entry, interf.getType())) {
-
-                        final OperationDataDefinition operation = new OperationDataDefinition();
-                        operation.setName(entry.getKey());
-
-                        final Map<?, ?> entryValue = (Map<?, ?>) entry.getValue();
-                        if (entryValue.containsKey(IMPLEMENTATION)) {
-                            operation.setImplementation(handleOperationImplementation(entry));
-                        }
-                        if (entryValue.containsKey(INPUTS)) {
-                            final Map<String, Object> interfaceInputs = (Map<String, Object>) entryValue
-                                .get(ToscaTagNamesEnum.INPUTS.getElementName());
-                            operation.setInputs(handleInterfaceInput(interfaceInputs));
-                        }
-                        operations.put(entry.getKey(), operation);
-                    }
-                }
-                if (!operations.isEmpty()) {
-                    interf.setOperations(operations);
-                }
-            } else {
-                result = Either.right(ResultStatusEnum.GENERAL_ERROR);
-            }
-
-        } catch (Exception e) {
-            BeEcompErrorManager.getInstance().logBeSystemError("Import Resource- create interface");
-            log.debug("error when creating interface, message:{}", e.getMessage(), e);
-            result = Either.right(ResultStatusEnum.GENERAL_ERROR);
-        }
-
-        return result;
-    }
-
-    private ArtifactDataDefinition handleOperationImplementation(final Entry<String, Object> entry) {
-        final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
-        final String artifactName = ((Map<String, String>) entry.getValue()).get(IMPLEMENTATION);
-        if (OperationArtifactUtil.artifactNameIsALiteralValue(artifactName)) {
-            implementation.setArtifactName(artifactName);
-        } else {
-            implementation.setArtifactName(QUOTE + artifactName + QUOTE);
-        }
-        return implementation;
-    }
-
-    private ListDataDefinition<OperationInputDefinition> handleInterfaceInput(
-        final Map<String, Object> interfaceInputs) {
-        final ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
-        for (final Entry<String, Object> interfaceInput : interfaceInputs.entrySet()) {
-            final OperationInputDefinition operationInput = new OperationInputDefinition();
-            operationInput.setName(interfaceInput.getKey());
-            if (interfaceInput.getValue() instanceof Map) {
-                final LinkedHashMap<String, Object> inputPropertyValue =
-                    (LinkedHashMap<String, Object>) interfaceInput.getValue();
-                log.info("createModuleInterface: i interfaceInput.getKey() {}, {} , {}  ",
-                    interfaceInput.getKey(), inputPropertyValue.keySet(),
-                    inputPropertyValue.values());
-                if (inputPropertyValue.get(TYPE) != null) {
-                    operationInput.setType(inputPropertyValue.get(TYPE).toString());
-                }
-                if (inputPropertyValue.get(DESCRIPTION) != null) {
-                    operationInput.setDescription(inputPropertyValue.get(DESCRIPTION).toString());
-                }
-                if (inputPropertyValue.get(REQUIRED) != null) {
-                    operationInput.setRequired(
-                        Boolean.getBoolean(inputPropertyValue.get(REQUIRED).toString()));
-                }
-                if (inputPropertyValue.get(DEFAULT) != null) {
-                    operationInput.setToscaDefaultValue(inputPropertyValue.get(DEFAULT).toString());
-                }
-                if (inputPropertyValue.get(STATUS) != null) {
-                    operationInput.setStatus(inputPropertyValue.get(STATUS).toString());
-                }
-
-            } else if (interfaceInput.getValue() instanceof String) {
-                final String value = (String) interfaceInput.getValue();
-                operationInput.setDefaultValue(value);
-                operationInput.setToscaDefaultValue(value);
-                operationInput.setValue(value);
+                final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+                interfaceDefinition.setType((String) interfaceJson);
+                return Either.left(interfaceDefinition);
             }
-            inputs.getListToscaDataDefinition().add(operationInput);
-            inputs.add(operationInput);
-        }
-        return inputs;
-    }
 
-    private boolean entryIsInterfaceType(final Entry<String, Object> entry) {
-        if(entry.getKey().equals(TypeUtils.ToscaTagNamesEnum.TYPE.getElementName())) {
-            if (entry.getValue() instanceof String) {
-                return true;
+            if (interfaceJson instanceof Map) {
+                final Map<String, Object> interfaceJsonMap = (Map<String, Object>) interfaceJson;
+                final InterfaceDefinition interfaceDefinition = interfaceDefinitionHandler.create(interfaceJsonMap);
+                return Either.left(interfaceDefinition);
             }
-            throw new ByActionStatusComponentException(ActionStatus.INVALID_YAML);
-        }
-        return false;
-    }
-
-    private boolean entryContainsImplementationForAKnownOperation(final Entry<String, Object> entry,
-                                                                  final String interfaceType) {
-        if (entry.getValue() instanceof Map && ((Map<?, ?>)entry.getValue()).containsKey(IMPLEMENTATION)) {
-            if (isAKnownOperation(interfaceType, entry.getKey())){
-                return true;
-            }
-            throw new ByActionStatusComponentException(ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
-        }
-        return false;
-    }
-
-    private boolean isAKnownOperation(String interfaceType, String operation) {
-        Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceLifecycleTypes = interfaceOperationBusinessLogic
-            .getAllInterfaceLifecycleTypes();
-        if (interfaceLifecycleTypes.isRight() || interfaceLifecycleTypes.left().value() == null) {
-            return false;
-        }
 
-        for (Entry<String, InterfaceDefinition> interfaceLifecycleType : interfaceLifecycleTypes.left().value()
-            .entrySet()) {
-            if (interfaceTypeAndOperationMatches(interfaceLifecycleType, interfaceType, operation)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private boolean interfaceTypeAndOperationMatches(Entry<String, InterfaceDefinition> interfaceLifecycleType,
-                                                     String interfaceType, String operation) {
-        if (interfaceLifecycleType.getKey().equalsIgnoreCase(interfaceType)
-            && interfaceLifecycleType.getValue().getOperations() != null) {
-            for (String interfaceLifecycleTypeOperation : interfaceLifecycleType.getValue().getOperations().keySet()) {
-                if (interfaceLifecycleTypeOperation != null && interfaceLifecycleTypeOperation
-                    .equalsIgnoreCase(operation)) {
-                    return true;
-                }
-            }
+            return Either.right(ResultStatusEnum.GENERAL_ERROR);
+        } catch (final Exception e) {
+            BeEcompErrorManager.getInstance().logBeSystemError("Import Resource- create interface");
+            log.debug("error when creating interface, message:{}", e.getMessage(), e);
+            return Either.right(ResultStatusEnum.GENERAL_ERROR);
         }
-        return false;
     }
 
     private void setRequirements(Map<String, Object> toscaJson, Resource resource,
@@ -1165,11 +1018,6 @@ public class ResourceImportManager {
         this.resourceBusinessLogic = resourceBusinessLogic;
     }
 
-    @Autowired
-    public void setInterfaceOperationBusinessLogic(InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
-        this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
-    }
-
     public IGraphLockOperation getGraphLockOperation() {
         return graphLockOperation;
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
index 9e9d834691..1f1dcfed8c 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/InterfacesOperationsConverter.java
@@ -16,10 +16,21 @@
 
 package org.openecomp.sdc.be.tosca;
 
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.INPUTS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.OPERATIONS;
+
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.gson.Gson;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
 import org.apache.commons.collections.MapUtils;
+import org.openecomp.sdc.be.datatypes.elements.InputDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.model.Component;
@@ -27,30 +38,27 @@ import org.openecomp.sdc.be.model.ComponentInstance;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.Product;
-import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType;
+import org.openecomp.sdc.be.tosca.model.ToscaInput;
 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceDefinition;
 import org.openecomp.sdc.be.tosca.model.ToscaInterfaceNodeType;
 import org.openecomp.sdc.be.tosca.model.ToscaLifecycleOperationDefinition;
 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
 import org.openecomp.sdc.be.tosca.utils.OperationArtifactUtil;
+import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
+import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-
 @Service
 public class InterfacesOperationsConverter {
 
 
     private static final String DERIVED_FROM_STANDARD_INTERFACE = "tosca.interfaces.node.lifecycle.Standard";
     private static final String DERIVED_FROM_BASE_DEFAULT = "org.openecomp.interfaces.node.lifecycle.";
-    private static final String OPERATIONS_KEY = "operations";
 
-    private static final String DEFAULT = "default";
     private static final String DEFAULT_HAS_UNDERSCORE = "_default";
     private static final String DOT = ".";
     private static final String DEFAULTP = "defaultp";
@@ -58,10 +66,10 @@ public class InterfacesOperationsConverter {
     public static final String SELF = "SELF";
     private static final String LOCAL_INTERFACE_TYPE = "Local";
 
-    private PropertyConvertor propertyConvertor;
+    private final PropertyConvertor propertyConvertor;
 
     @Autowired
-    public InterfacesOperationsConverter(PropertyConvertor propertyConvertor) {
+    public InterfacesOperationsConverter(final PropertyConvertor propertyConvertor) {
         this.propertyConvertor = propertyConvertor;
     }
 
@@ -96,7 +104,7 @@ public class InterfacesOperationsConverter {
                 }
                 toscaInterfaceType.setOperations(toscaOperations);
                 Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
-                Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS_KEY);
+                Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS.getElementName());
                 interfacesAsMap.putAll(operationsMap);
 
                 toscaInterfaceTypes.put(getInterfaceType(component, LOCAL_INTERFACE_TYPE), interfacesAsMap);
@@ -134,12 +142,12 @@ public class InterfacesOperationsConverter {
         return getInterfacesMap(component, null, component.getInterfaces(), dataTypes, isAssociatedComponent, false);
     }
 
-    public Map<String, Object> getInterfacesMap(Component component,
-                                                       ComponentInstance componentInstance,
-                                                       Map<String, InterfaceDefinition> interfaces,
-                                                       Map<String, DataTypeDefinition> dataTypes,
-                                                       boolean isAssociatedComponent,
-                                                       boolean isServiceProxyInterface) {
+    public Map<String, Object> getInterfacesMap(final Component component,
+                                                final ComponentInstance componentInstance,
+                                                final Map<String, InterfaceDefinition> interfaces,
+                                                final Map<String, DataTypeDefinition> dataTypes,
+                                                final boolean isAssociatedComponent,
+                                                final boolean isServiceProxyInterface) {
         if(MapUtils.isEmpty(interfaces)) {
             return null;
         }
@@ -155,7 +163,7 @@ public class InterfacesOperationsConverter {
             }
             toscaInterfaceDefinition.setType(interfaceType);
             final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
-            Map<String, Object> toscaOperations = new HashMap<>();
+            Map<String, Object> toscaOperationMap = new HashMap<>();
 
             String operationArtifactPath;
             for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
@@ -169,12 +177,20 @@ public class InterfacesOperationsConverter {
                 toscaOperation.setDescription(operationEntry.getValue().getDescription());
                 fillToscaOperationInputs(operationEntry.getValue(), dataTypes, toscaOperation, isServiceProxyInterface);
 
-                toscaOperations.put(operationEntry.getValue().getName(), toscaOperation);
+                toscaOperationMap.put(operationEntry.getValue().getName(), toscaOperation);
+            }
+            toscaInterfaceDefinition.setOperations(toscaOperationMap);
+
+            final Map<String, Object> interfaceInputMap = createInterfaceInputMap(interfaceDefinition, dataTypes);
+            if (!interfaceInputMap.isEmpty()) {
+                toscaInterfaceDefinition.setInputs(interfaceInputMap);
             }
 
-            toscaInterfaceDefinition.setOperations(toscaOperations);
             Map<String, Object> interfaceDefAsMap = getObjectAsMap(toscaInterfaceDefinition);
-            Map<String, Object> operationsMap = (Map<String, Object>) interfaceDefAsMap.remove(OPERATIONS_KEY);
+            if (interfaceDefAsMap.containsKey(INPUTS.getElementName())) {
+                handleDefaults((Map<String, Object>) interfaceDefAsMap.get(INPUTS.getElementName()));
+            }
+            Map<String, Object> operationsMap = (Map<String, Object>) interfaceDefAsMap.remove(OPERATIONS.getElementName());
             if (isServiceProxyInterface) {
                 //Remove input type and copy default value directly into the proxy node template from the node type
                 handleServiceProxyOperationInputValue(operationsMap, interfaceType);
@@ -188,6 +204,22 @@ public class InterfacesOperationsConverter {
         return toscaInterfaceDefinitions;
     }
 
+    private Map<String, Object> createInterfaceInputMap(final InterfaceDefinition interfaceDefinition,
+                                                        final Map<String, DataTypeDefinition> allDataTypeMap) {
+        final Map<String, InputDataDefinition> inputMap = interfaceDefinition.getInputs();
+        if (MapUtils.isEmpty(inputMap)) {
+            return Collections.emptyMap();
+        }
+        final Map<String, Object> toscaInterfaceInputMap = new HashMap<>();
+        for (final Entry<String, InputDataDefinition> inputEntry : inputMap.entrySet()) {
+            final InputDataDefinition inputDataDefinition = inputEntry.getValue();
+            final ToscaProperty toscaProperty = propertyConvertor
+                .convertProperty(allDataTypeMap, new PropertyDefinition(inputDataDefinition), PropertyType.INPUT);
+            toscaInterfaceInputMap.put(inputEntry.getKey(), new ToscaInput(toscaProperty));
+        }
+        return toscaInterfaceInputMap;
+    }
+
     private static void handleServiceProxyOperationInputValue(Map<String, Object> operationsMap, String parentKey) {
         for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
             final Object value = operationEntry.getValue();
@@ -223,7 +255,7 @@ public class InterfacesOperationsConverter {
      * ToscaExportHandler so, any string Map key named "defaultp" will have its named changed to "default"
      * @param operationsMap the map to update
      */
-    private static void handleDefaults(Map<String, Object> operationsMap) {
+    private void handleDefaults(Map<String, Object> operationsMap) {
         for (Map.Entry<String, Object> operationEntry : operationsMap.entrySet()) {
             final Object value = operationEntry.getValue();
             if (value instanceof Map) {
@@ -232,7 +264,7 @@ public class InterfacesOperationsConverter {
             final String key = operationEntry.getKey();
             if (key.equals(DEFAULTP)) {
                 Object removed = operationsMap.remove(key);
-                operationsMap.put(DEFAULT, removed);
+                operationsMap.put(ToscaTagNamesEnum.DEFAULT.getElementName(), removed);
             }
         }
     }
@@ -314,10 +346,9 @@ public class InterfacesOperationsConverter {
         Map<String, Object> objectAsMap =
                 obj instanceof Map ? (Map<String, Object>) obj : objectMapper.convertValue(obj, Map.class);
 
-        if (objectAsMap.containsKey(DEFAULT)) {
-            Object defaultValue = objectAsMap.get(DEFAULT);
-            objectAsMap.remove(DEFAULT);
-            objectAsMap.put(DEFAULT_HAS_UNDERSCORE, defaultValue);
+        final String defaultEntry = DEFAULT.getElementName();
+        if (objectAsMap.containsKey(defaultEntry)) {
+            objectAsMap.put(DEFAULT_HAS_UNDERSCORE, objectAsMap.remove(defaultEntry));
         }
         return objectAsMap;
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java
index 1d444e697a..2f4a3d8ac1 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/model/ToscaInterfaceDefinition.java
@@ -16,35 +16,20 @@
 package org.openecomp.sdc.be.tosca.model;
 
 import java.util.Map;
+import lombok.Getter;
+import lombok.Setter;
 
 /**
  * @author KATYR
  * @since March 26, 2018
  */
-
+@Setter
+@Getter
 public class ToscaInterfaceDefinition {
 
     private String type;
-    private Map<String, Object> operations; // ToscaLifecycleOperationDefinition <-> Object
-
-    public String getType() {
-        return type;
-    }
-
-    public void setType(String type) {
-        this.type = type;
-    }
-
-    public Map<String, Object> getOperations() {
-        return operations;
-    }
-
-//    public void setOperations(Map<String, Object> operations) {
-//        this.operations = operations;
-//    }
+    private Map<String, Object> operations;
+    private Map<String, Object> inputs;
 
-    public void setOperations(Map<String,Object> toscaOperations) {
-        this.operations = toscaOperations;
-    }
 }