Revert "Interface operation feature enhancements"

This reverts commit 01f825bc

Change-Id: I9e41da46a410be335283a27758cb1e77a087046f
Issue-ID: SDC-1999
Signed-off-by: priyanshu <pagarwal@amdocs.com>

13 files changed, 499 insertions, 577 deletions

diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java
index ef29b93001..2b3ee0ed2e 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ArtifactsBusinessLogic.java
@@ -56,7 +56,7 @@ import org.openecomp.sdc.be.model.*;
 import org.openecomp.sdc.be.model.heat.HeatParameterType;
 import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation;
 import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation;
-import org.openecomp.sdc.be.components.utils.InterfaceOperationUtils;
+import org.openecomp.sdc.be.model.jsontitan.utils.InterfaceUtils;
 import org.openecomp.sdc.be.model.operations.api.*;
 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
@@ -3058,7 +3058,7 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
             }
         } else {
             return updateArtifactsFlowForInterfaceOperations(parent, parentId, artifactId, artifactInfo, user,
-                    decodedPayload, componentType, auditingAction, interfaceType, operationUuid, artifactData, prevArtifactId,
+                    decodedPayload, componentType, auditingAction, operationUuid, artifactData, prevArtifactId,
                     currArtifactId, artifactDefinition);
         }
 
@@ -3067,7 +3067,7 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
 
     private Either<Either<ArtifactDefinition, Operation>, ResponseFormat> updateArtifactsFlowForInterfaceOperations(
             Component parent, String parentId, String artifactId, ArtifactDefinition artifactInfo, User user,
-            byte[] decodedPayload, ComponentTypeEnum componentType, AuditingActionEnum auditingAction, String interfaceType,
+            byte[] decodedPayload, ComponentTypeEnum componentType, AuditingActionEnum auditingAction,
             String operationUuid, ESArtifactData artifactData, String prevArtifactId, String currArtifactId,
             ArtifactDefinition artifactDefinition) {
         StorageOperationStatus error;
@@ -3110,15 +3110,24 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
         }
         Component storedComponent = componentStorageOperationStatusEither.left().value();
 
-        Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
-            .getInterfaceDefinitionFromComponentByInterfaceType(storedComponent, interfaceType);
-        if(!optionalInterface.isPresent()) {
+        String interfaceToscaName = InterfaceUtils.createInterfaceToscaResourceName(
+                storedComponent.getName());
+        //fetch the interface from storage
+        Optional<InterfaceDefinition> interfaceDefinition =
+                storedComponent.getInterfaces().values().stream()
+                        .filter(interfaceDef -> interfaceDef.getToscaResourceName()
+                        .equals(interfaceToscaName)).findFirst();
+        if (!interfaceDefinition.isPresent()) {
             log.debug("Failed to get resource interface for resource Id {}", parentId);
-            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceType));
+            ResponseFormat responseFormat = componentsUtils.getResponseFormat(
+                    ActionStatus.INTERFACE_OPERATION_NOT_FOUND, parentId);
+            handleAuditing(auditingAction, parent, parentId, user, artifactInfo, prevArtifactId,
+                    currArtifactId, responseFormat, componentType, null);
+            return Either.right(responseFormat);
         }
 
         //fetch the operation from storage
-        InterfaceDefinition gotInterface = optionalInterface.get();
+        InterfaceDefinition gotInterface = interfaceDefinition.get();
         Map<String, Operation> operationsMap = gotInterface.getOperationsMap();
         Optional<Operation> optionalOperation = operationsMap.values()
                 .stream()
@@ -3143,8 +3152,8 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
         implementationArtifact.setEsId(artifactInfo.getEsId());
         operation.setImplementation(implementationArtifact);
         gotInterface.setOperationsMap(operationsMap);
-        Either<List<InterfaceDefinition>, StorageOperationStatus> interfaceDefinitionStorageOperationStatusEither =
-                interfaceOperation.updateInterfaces(storedComponent.getUniqueId(), Collections.singletonList(gotInterface));
+        Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinitionStorageOperationStatusEither =
+                interfaceOperation.updateInterface(storedComponent.getUniqueId(), gotInterface);
         if (interfaceDefinitionStorageOperationStatusEither.isRight()){
             StorageOperationStatus storageOperationStatus = interfaceDefinitionStorageOperationStatusEither.right().value();
             ActionStatus actionStatus =
@@ -5018,13 +5027,13 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
      * @param componentType
      * @param componentUuid
      * @param artifactUUID
-     * @param operation
+     * @param operation        TODO
      * @return
      */
     public Either<ArtifactDefinition, ResponseFormat> updateArtifactOnInterfaceOperationByResourceUUID(
             String data, HttpServletRequest request, ComponentTypeEnum componentType,
-            String componentUuid, String interfaceUUID, String operationUUID, String artifactUUID,
-        ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
+            String componentUuid, String artifactUUID, String operationUUID,
+            ResourceCommonInfo resourceCommonInfo,ArtifactOperationInfo operation) {
         Wrapper<ResponseFormat> errorWrapper = new Wrapper<>();
         Either<ArtifactDefinition, ResponseFormat> updateArtifactResult;
         Either<Either<ArtifactDefinition, Operation>, ResponseFormat> actionResult = null;
@@ -5058,7 +5067,7 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
             resourceCommonInfo.setResourceName(componentName);
         }
         if (errorWrapper.isEmpty()) {
-            Either<String, ResponseFormat> interfaceName = fetchInterfaceName(componentId, interfaceUUID);
+            Either<String, ResponseFormat> interfaceName = fetchInterfaceName(componentId);
             if (interfaceName.isRight()) {
                 errorWrapper.setInnerElement(interfaceName.right().value());
             }
@@ -5085,21 +5094,19 @@ public class ArtifactsBusinessLogic extends BaseBusinessLogic {
         return updateArtifactResult;
     }
 
-    private Either<String, ResponseFormat> fetchInterfaceName(String componentId, String interfaceUUID) {
-        Either<Component, StorageOperationStatus> componentStorageOperationStatusEither = toscaOperationFacade.getToscaElement(componentId);
+    private Either<String, ResponseFormat> fetchInterfaceName(String componentId) {
+        Either<Component, StorageOperationStatus> componentStorageOperationStatusEither =
+                toscaOperationFacade.getToscaElement(componentId);
         if (componentStorageOperationStatusEither.isRight()) {
             StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
             log.debug("Failed to fetch component information by component id, error {}", errorStatus);
-            return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
+            return Either.right(componentsUtils
+                    .getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
         }
         Component storedComponent = componentStorageOperationStatusEither.left().value();
 
-        Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
-            .getInterfaceDefinitionFromComponentByInterfaceId(storedComponent, interfaceUUID);
-        if(!optionalInterface.isPresent()) {
-            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceUUID));
-        }
-        return Either.left(optionalInterface.get().getType());
+        return Either.left(InterfaceUtils.createInterfaceToscaResourceName(
+                storedComponent.getName()));
     }
 
 
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
index 8ee1864862..02e64334f9 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java
@@ -128,7 +128,10 @@ public abstract class BaseBusinessLogic {
     protected InterfaceOperation interfaceOperation;
 
     @Autowired
-    protected InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
+    protected InterfaceOperationBusinessLogic interfaceOperationBusinessLogic;
+
+    @Autowired
+    protected InterfaceLifecycleOperation interfaceLifecycleOperation;
 
     @javax.annotation.Resource
     private UserValidations userValidations;
@@ -164,6 +167,18 @@ public abstract class BaseBusinessLogic {
         this.propertyOperation = propertyOperation;
     }
 
+    public void setInterfaceOperation(InterfaceOperation interfaceOperation) {
+        this.interfaceOperation = interfaceOperation;
+    }
+    public void setInterfaceOperationBusinessLogic(InterfaceOperationBusinessLogic interfaceOperationBusinessLogic) {
+        this.interfaceOperationBusinessLogic = interfaceOperationBusinessLogic;
+    }
+
+
+    public void setInterfaceLifecycleOperation(InterfaceLifecycleOperation interfaceLifecycleOperation) {
+        this.interfaceLifecycleOperation = interfaceLifecycleOperation;
+    }
+
     User validateUserNotEmpty(User user, String ecompErrorContext) {
         return userValidations.validateUserNotEmpty(user, ecompErrorContext);
     }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
index 2bb53d01e7..a0efddbdda 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java
@@ -18,28 +18,15 @@
 package org.openecomp.sdc.be.components.impl;
 
 import fj.data.Either;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.UUID;
-import java.util.stream.Collectors;
-import org.openecomp.sdc.be.components.utils.InterfaceOperationUtils;
 import org.openecomp.sdc.be.components.validation.InterfaceOperationValidation;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
-import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
-import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
-import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
 import org.openecomp.sdc.be.model.ArtifactDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.Operation;
 import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.jsontitan.utils.InterfaceUtils;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
@@ -60,6 +47,7 @@ import java.util.stream.Collectors;
 public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceOperationBusinessLogic.class);
+    private static final String FAILED_TO_LOCK_COMPONENT_RESPONSE_IS = "Failed to lock component {}. Response is {}";
     private static final String EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION = "Exception occurred during {}. Response is {}";
     private static final String DELETE_INTERFACE_OPERATION = "deleteInterfaceOperation";
     private static final String GET_INTERFACE_OPERATION = "getInterfaceOperation";
@@ -67,19 +55,19 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
     private static final String UPDATE_INTERFACE_OPERATION = "updateInterfaceOperation";
 
     @Autowired
-    private ArtifactCassandraDao artifactCassandraDao;
-
-    @Autowired
     private InterfaceOperationValidation interfaceOperationValidation;
 
-    public Either<List<InterfaceDefinition>, ResponseFormat> deleteInterfaceOperation(String componentId, String interfaceId, List<String> operationsToDelete, User user, boolean lock) {
-        validateUserExists(user.getUserId(), DELETE_INTERFACE_OPERATION, true);
+    public void setInterfaceOperationValidation(InterfaceOperationValidation interfaceOperationValidation) {
+        this.interfaceOperationValidation = interfaceOperationValidation;
+    }
 
+    public Either<Operation, ResponseFormat> deleteInterfaceOperation(String componentId, String interfaceOperationToDelete, User user, boolean lock) {
         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
         if (componentEither.isRight()){
             return Either.right(componentEither.right().value());
         }
         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
+        validateUserExists(user.getUserId(), DELETE_INTERFACE_OPERATION, true);
 
         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, DELETE_INTERFACE_OPERATION);
         if (lockResult.isRight()) {
@@ -87,53 +75,26 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
         }
 
         try {
-            Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
-                .getInterfaceDefinitionFromComponentByInterfaceId(storedComponent, interfaceId);
-            if(!optionalInterface.isPresent()) {
-                return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceId));
+            Optional<InterfaceDefinition> optionalInterface = InterfaceUtils.getInterfaceDefinitionFromToscaName(storedComponent.getInterfaces().values(), storedComponent.getName());
+            Either<InterfaceDefinition, ResponseFormat> getInterfaceEither = getInterfaceDefinition(storedComponent, optionalInterface.orElse(null));
+            if (getInterfaceEither.isRight()) {
+                return Either.right(getInterfaceEither.right().value());
             }
-            InterfaceDefinition interfaceDefinition = optionalInterface.get();
-
-            Map<String, Operation> operationsCollection = new HashMap<>();
-            for (String operationId : operationsToDelete){
-                Optional<Map.Entry<String, Operation>> optionalOperation = InterfaceOperationUtils
-                    .getOperationFromInterfaceDefinition(interfaceDefinition, operationId);
-                if(!optionalOperation.isPresent()){
-                    return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, storedComponent.getUniqueId()));
-                }
+            InterfaceDefinition interfaceDefinition = getInterfaceEither.left().value();
 
-                Operation storedOperation = optionalOperation.get().getValue();
-                String artifactUUID = storedOperation.getImplementation().getArtifactUUID();
-                CassandraOperationStatus cassandraStatus = artifactCassandraDao.deleteArtifact(artifactUUID);
-                if (cassandraStatus != CassandraOperationStatus.OK) {
-                    ResponseFormat responseFormatByArtifactId = componentsUtils.getResponseFormatByArtifactId(
-                        componentsUtils.convertFromStorageResponse(componentsUtils.convertToStorageOperationStatus(cassandraStatus)),
-                        storedOperation.getImplementation().getArtifactDisplayName());
-                    return Either.right(responseFormatByArtifactId);
-                }
-
-                operationsCollection.put(operationId, interfaceDefinition.getOperationsMap().get(operationId));
-                interfaceDefinition.getOperations().remove(operationId);
-            }
-
-            Either<List<InterfaceDefinition>, StorageOperationStatus> deleteOperationEither = interfaceOperation.updateInterfaces(storedComponent.getUniqueId(), Collections.singletonList(interfaceDefinition));
-            if (deleteOperationEither.isRight()) {
-                titanDao.rollback();
-                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(deleteOperationEither.right().value(), storedComponent.getComponentType())));
+            Either<Operation, ResponseFormat> getOperationEither = getOperationFromInterfaceDef(storedComponent, interfaceDefinition, interfaceOperationToDelete);
+            if (getOperationEither.isRight()){
+                return Either.right(getOperationEither.right().value());
             }
 
-            if(interfaceDefinition.getOperations().isEmpty()) {
-                Either<String, StorageOperationStatus> deleteInterfaceEither = interfaceOperation.deleteInterface(storedComponent.getUniqueId(), interfaceDefinition.getUniqueId());
-                if (deleteInterfaceEither.isRight()) {
-                    titanDao.rollback();
-                    return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(deleteInterfaceEither.right().value(), storedComponent.getComponentType())));
-                }
+            Either<Operation, StorageOperationStatus> deleteEither = interfaceOperation.deleteInterfaceOperation(componentId, interfaceDefinition, interfaceOperationToDelete);
+            if (deleteEither.isRight()){
+                LOGGER.error("Failed to delete interface operation from component {}. Response is {}", storedComponent.getName(), deleteEither.right().value());
+                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(deleteEither.right().value(), storedComponent.getComponentType())));
             }
 
             titanDao.commit();
-            interfaceDefinition.getOperations().putAll(operationsCollection);
-            interfaceDefinition.getOperations().keySet().removeIf(key -> !(operationsToDelete.contains(key)));
-            return Either.left(Arrays.asList(interfaceDefinition));
+            return Either.left(deleteEither.left().value());
         }
         catch (Exception e){
             LOGGER.error(EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION, "delete", e);
@@ -147,14 +108,13 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
         }
     }
 
-    public Either<List<InterfaceDefinition>, ResponseFormat> getInterfaceOperation(String componentId, String interfaceId, List<String> operationsToGet, User user, boolean lock) {
-        validateUserExists(user.getUserId(), GET_INTERFACE_OPERATION, true);
-
+    public Either<Operation, ResponseFormat> getInterfaceOperation(String componentId, String interfaceOperationToGet, User user, boolean lock) {
         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
         if (componentEither.isRight()){
             return Either.right(componentEither.right().value());
         }
         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
+        validateUserExists(user.getUserId(), GET_INTERFACE_OPERATION, true);
 
         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, GET_INTERFACE_OPERATION);
         if (lockResult.isRight()) {
@@ -162,24 +122,20 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
         }
 
         try {
-            Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils
-                .getInterfaceDefinitionFromComponentByInterfaceId(storedComponent, interfaceId);
-            if(!optionalInterface.isPresent()) {
-                return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceId));
+            Optional<InterfaceDefinition> optionalInterface = InterfaceUtils.getInterfaceDefinitionFromToscaName(storedComponent.getInterfaces().values(), storedComponent.getName());
+            Either<InterfaceDefinition, ResponseFormat> getInterfaceEither = getInterfaceDefinition(storedComponent, optionalInterface.orElse(null));
+            if (getInterfaceEither.isRight()) {
+                return Either.right(getInterfaceEither.right().value());
             }
-            InterfaceDefinition interfaceDefinition = optionalInterface.get();
+            InterfaceDefinition interfaceDefinition = getInterfaceEither.left().value();
 
-            for (String operationId : operationsToGet) {
-                Optional<Map.Entry<String, Operation>> optionalOperation = InterfaceOperationUtils
-                    .getOperationFromInterfaceDefinition(interfaceDefinition, operationId);
-                if(!optionalOperation.isPresent()){
-                    return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, storedComponent.getUniqueId()));
-                }
+            Either<Operation, ResponseFormat> getOperationEither = getOperationFromInterfaceDef(storedComponent, interfaceDefinition, interfaceOperationToGet);
+            if (getOperationEither.isRight()){
+                return Either.right(getOperationEither.right().value());
             }
 
             titanDao.commit();
-            interfaceDefinition.getOperations().keySet().removeIf(key -> !(operationsToGet.contains(key)));
-            return Either.left(Arrays.asList(interfaceDefinition));
+            return Either.left(getOperationEither.left().value());
         }
         catch (Exception e){
             LOGGER.error(EXCEPTION_OCCURRED_DURING_INTERFACE_OPERATION, "get", e);
@@ -193,110 +149,78 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
         }
     }
 
-    public Either<List<InterfaceDefinition>, ResponseFormat> createInterfaceOperation(String componentId, List<InterfaceDefinition> interfaceDefinitions, User user, boolean lock) {
-        return createOrUpdateInterfaceOperation(componentId, interfaceDefinitions, user, false, CREATE_INTERFACE_OPERATION, lock);
+    private Either<InterfaceDefinition, ResponseFormat> getInterfaceDefinition(org.openecomp.sdc.be.model.Component component, InterfaceDefinition interfaceDef) {
+        if (interfaceDef != null){
+            return Either.left(interfaceDef);
+        } else {
+            InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+            interfaceDefinition.setToscaResourceName(InterfaceUtils.createInterfaceToscaResourceName(component.getName()));
+            Either<InterfaceDefinition, StorageOperationStatus> interfaceCreateEither = interfaceOperation.addInterface(component.getUniqueId(), interfaceDefinition);
+            if (interfaceCreateEither.isRight()){
+                StorageOperationStatus sValue = interfaceCreateEither.right().value();
+                LOGGER.error("Failed to get interface from component {}. Response is {}", component.getName(), sValue);
+                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(sValue, component.getComponentType()), ""));
+            }
+            return Either.left(interfaceCreateEither.left().value());
+        }
     }
 
-    public Either<List<InterfaceDefinition>, ResponseFormat> updateInterfaceOperation(String componentId, List<InterfaceDefinition> interfaceDefinitions, User user, boolean lock) {
-        return createOrUpdateInterfaceOperation(componentId, interfaceDefinitions, user, true, UPDATE_INTERFACE_OPERATION, lock);
+    public Either<Operation, ResponseFormat> createInterfaceOperation(String componentId, Operation operation, User user, boolean lock) {
+        return createOrUpdateInterfaceOperation(componentId, operation, user, false, CREATE_INTERFACE_OPERATION, lock);
     }
 
-    public Either<Map<String, InterfaceDefinition>, ResponseFormat> getAllInterfaceLifecycleTypes() {
-
-        Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfaceLifecycleTypes = interfaceLifecycleTypeOperation.getAllInterfaceLifecycleTypes();
-        if(interfaceLifecycleTypes.isRight()) {
-            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_LIFECYCLE_TYPES_NOT_FOUND));
-        }
-        interfaceLifecycleTypes.left().value().values().stream().forEach(
-            id -> id.setOperations(id.getOperations().keySet().stream().collect(Collectors.toMap(key -> key.replaceFirst(id.getUniqueId()+".",""), i -> id.getOperations().get(i)))));
-
-        return Either.left(interfaceLifecycleTypes.left().value());
+    public Either<Operation, ResponseFormat> updateInterfaceOperation(String componentId, Operation operation, User user, boolean lock) {
+        return createOrUpdateInterfaceOperation(componentId, operation, user, true, UPDATE_INTERFACE_OPERATION, lock);
     }
 
-    private Either<List<InterfaceDefinition>, ResponseFormat> createOrUpdateInterfaceOperation(String componentId, List<InterfaceDefinition> interfaceDefinitions, User user, boolean isUpdate, String errorContext, boolean lock) {
-        validateUserExists(user.getUserId(), errorContext, true);
-
+    private Either<Operation, ResponseFormat> createOrUpdateInterfaceOperation(String componentId, Operation operation, User user, boolean isUpdate, String errorContext, boolean lock) {
         Either<org.openecomp.sdc.be.model.Component, ResponseFormat> componentEither = getComponentDetails(componentId);
         if (componentEither.isRight()){
             return Either.right(componentEither.right().value());
         }
         org.openecomp.sdc.be.model.Component storedComponent = componentEither.left().value();
+        validateUserExists(user.getUserId(), errorContext, true);
+        Either<Boolean, ResponseFormat> interfaceOperationValidationResponseEither = interfaceOperationValidation
+            .validateInterfaceOperations(Collections.singletonList(operation), storedComponent, isUpdate);
+        if(interfaceOperationValidationResponseEither.isRight()) {
+            return 	Either.right(interfaceOperationValidationResponseEither.right().value());
+        }
 
         Either<Boolean, ResponseFormat> lockResult = lockComponentResult(lock, storedComponent, errorContext);
         if (lockResult.isRight()) {
             return Either.right(lockResult.right().value());
         }
 
-        Either<Map<String, InterfaceDefinition>, ResponseFormat> interfaceLifecycleTypes = getAllInterfaceLifecycleTypes();
-        if (interfaceLifecycleTypes.isRight()) {
-            return Either.right(interfaceLifecycleTypes.right().value());
-        }
-
         try {
-            List<InterfaceDefinition> interfacesCollection = new ArrayList<>();
-            Map<String, Operation> operationsCollection = new HashMap<>();
-            for(InterfaceDefinition inputInterfaceDefinition : interfaceDefinitions) {
-                Optional<InterfaceDefinition> optionalInterface = InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(storedComponent, inputInterfaceDefinition.getType());
-                Either<Boolean, ResponseFormat> interfaceOperationValidationResponseEither = interfaceOperationValidation.validateInterfaceOperations(inputInterfaceDefinition, storedComponent,
-                    optionalInterface.orElse(null), interfaceLifecycleTypes.left().value(), isUpdate);
-                if(interfaceOperationValidationResponseEither.isRight()) {
-                    return 	Either.right(interfaceOperationValidationResponseEither.right().value());
-                }
-
-                Map<String, Operation> operationsToAddOrUpdate = inputInterfaceDefinition.getOperationsMap();
-                operationsCollection.putAll(operationsToAddOrUpdate);
-                inputInterfaceDefinition.getOperations().clear();
+            Optional<InterfaceDefinition> optionalInterface = InterfaceUtils.getInterfaceDefinitionFromToscaName(storedComponent.getInterfaces().values(), storedComponent.getName());
+            Either<InterfaceDefinition, ResponseFormat> getInterfaceEither = getInterfaceDefinition(storedComponent, optionalInterface.orElse(null));
+            if (getInterfaceEither.isRight()) {
+                return Either.right(getInterfaceEither.right().value());
+            }
+            InterfaceDefinition interfaceDefinition = getInterfaceEither.left().value();
 
-                Either<InterfaceDefinition, ResponseFormat> getInterfaceEither = getOrCreateInterfaceDefinition(storedComponent, inputInterfaceDefinition, optionalInterface.orElse(null));
-                if (getInterfaceEither.isRight()) {
-                    return Either.right(getInterfaceEither.right().value());
-                }
-                InterfaceDefinition interfaceDef = getInterfaceEither.left().value();
-
-                updateOperationInputDefs(storedComponent, operationsToAddOrUpdate.values());
-
-                for (Operation operation : operationsToAddOrUpdate.values()) {
-                    if (!isUpdate) {
-                        addOperationToInterface(interfaceDef, operation);
-                    }
-                    else {
-                        Optional<Map.Entry<String, Operation>> optionalOperation = InterfaceOperationUtils
-                            .getOperationFromInterfaceDefinition(interfaceDef, operation.getUniqueId());
-                        if(!optionalOperation.isPresent()){
-                            titanDao.rollback();
-                            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, storedComponent.getUniqueId()));
-                        }
-
-                        Operation storedOperation = optionalOperation.get().getValue();
-                        String artifactUUID = storedOperation.getImplementation().getArtifactUUID();
-                        Either<Long, CassandraOperationStatus> artifactCount = artifactCassandraDao.getCountOfArtifactById(artifactUUID);
-                        if(artifactCount.isLeft()){
-                            CassandraOperationStatus cassandraStatus = artifactCassandraDao.deleteArtifact(artifactUUID);
-                            if (cassandraStatus != CassandraOperationStatus.OK) {
-                                titanDao.rollback();
-                                ResponseFormat responseFormatByArtifactId = componentsUtils.getResponseFormatByArtifactId(
-                                    componentsUtils.convertFromStorageResponse(componentsUtils.convertToStorageOperationStatus(cassandraStatus)),
-                                    storedOperation.getImplementation().getArtifactDisplayName());
-                                return Either.right(responseFormatByArtifactId);
-                            }
-                        }
-                        updateOperationOnInterface(interfaceDef, operation, artifactUUID);
-                    }
+            Either<Operation, StorageOperationStatus> result;
+            if(!isUpdate){
+                initNewOperation(operation);
+                result = interfaceOperation.addInterfaceOperation(componentId, interfaceDefinition, operation);
+            }
+            else {
+                Either<Operation, ResponseFormat> getOperationEither = getOperationFromInterfaceDef(storedComponent, interfaceDefinition, operation.getUniqueId());
+                if (getOperationEither.isRight()){
+                    return Either.right(getOperationEither.right().value());
                 }
-                interfacesCollection.add(interfaceDef);
+                updateExistingOperation(operation, getOperationEither.left().value().getImplementation().getArtifactUUID());
+                result = interfaceOperation.updateInterfaceOperation(componentId, interfaceDefinition, operation);
             }
 
-            Either<List<InterfaceDefinition>, StorageOperationStatus> addCreateOperationEither = interfaceOperation.updateInterfaces(storedComponent.getUniqueId(), interfacesCollection);
-            if (addCreateOperationEither.isRight()) {
+            if (result.isRight()) {
                 titanDao.rollback();
-                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(addCreateOperationEither.right().value(), storedComponent.getComponentType())));
+                LOGGER.debug("Failed to addOrUpdate interface operation on component {}. Response is {}", storedComponent.getName(), result.right().value());
+                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(result.right().value(), storedComponent.getComponentType())));
             }
 
             titanDao.commit();
-            interfacesCollection.forEach(interfaceDefinition -> interfaceDefinition.getOperations().entrySet()
-                    .removeIf(entry -> !operationsCollection.values().stream().map(OperationDataDefinition::getName)
-                            .collect(Collectors.toList()).contains(entry.getValue().getName())));
-            return Either.left(interfacesCollection);
+            return Either.left(result.left().value());
         }
         catch (Exception e) {
             titanDao.rollback();
@@ -313,69 +237,104 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic {
     private Either<org.openecomp.sdc.be.model.Component, ResponseFormat> getComponentDetails(String componentId){
         Either<org.openecomp.sdc.be.model.Component, StorageOperationStatus> componentStorageOperationStatusEither = toscaOperationFacade.getToscaElement(componentId);
         if (componentStorageOperationStatusEither.isRight()) {
-            return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(componentStorageOperationStatusEither.right().value())));
+            StorageOperationStatus errorStatus = componentStorageOperationStatusEither.right().value();
+            LOGGER.error("Failed to fetch component information by component id {}, Response is {}", componentId, errorStatus);
+            return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(errorStatus)));
         }
         return Either.left(componentStorageOperationStatusEither.left().value());
     }
 
-    private Either<Boolean, ResponseFormat> lockComponentResult(boolean lock, org.openecomp.sdc.be.model.Component component, String action){
-        if (lock) {
-            Either<Boolean, ResponseFormat> lockResult = lockComponent(component.getUniqueId(), component, action);
-            if (lockResult.isRight()) {
-                titanDao.rollback();
-                return Either.right(lockResult.right().value());
-            }
+    private Either<Operation, ResponseFormat> getOperationFromInterfaceDef(
+        org.openecomp.sdc.be.model.Component component, InterfaceDefinition interfaceDefinition, String operationToFetch) {
+        Optional<Map.Entry<String, Operation>> operationMap = interfaceDefinition.getOperationsMap().entrySet().stream()
+            .filter(entry -> entry.getValue().getUniqueId().equals(operationToFetch)).findAny();
+        if (!operationMap.isPresent()) {
+            LOGGER.error("Failed to get interface operation from component {}. Response is {}", component.getUniqueId(), ActionStatus.INTERFACE_OPERATION_NOT_FOUND);
+            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_OPERATION_NOT_FOUND, component.getUniqueId()));
         }
-        return Either.left(true);
+        return Either.left(operationMap.get().getValue());
     }
 
-    private Either<InterfaceDefinition, ResponseFormat> getOrCreateInterfaceDefinition(org.openecomp.sdc.be.model.Component component, InterfaceDefinition interfaceDefinition, InterfaceDefinition storedInterfaceDef) {
-        if (storedInterfaceDef != null){
-            return Either.left(storedInterfaceDef);
-        }
-        else {
-            interfaceDefinition.setUniqueId(UUID.randomUUID().toString());
-            interfaceDefinition.setToscaResourceName(interfaceDefinition.getType());
-            Either<List<InterfaceDefinition>, StorageOperationStatus> interfaceCreateEither = interfaceOperation.addInterfaces(component.getUniqueId(), Collections.singletonList(interfaceDefinition));
-            if (interfaceCreateEither.isRight()){
-                titanDao.rollback();
-                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(interfaceCreateEither.right().value(), component.getComponentType())));
-            }
-            return Either.left(interfaceCreateEither.left().value().get(0));
-        }
-    }
-
-    private void addOperationToInterface(InterfaceDefinition interfaceDefinition, Operation interfaceOperation){
+    private void initNewOperation(Operation operation){
         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
         String artifactUUID = UUID.randomUUID().toString();
         artifactDefinition.setArtifactUUID(artifactUUID);
         artifactDefinition.setUniqueId(artifactUUID);
         artifactDefinition.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
-        interfaceOperation.setUniqueId(UUID.randomUUID().toString());
-        interfaceOperation.setImplementation(artifactDefinition);
-        interfaceDefinition.getOperations().put(interfaceOperation.getUniqueId(), new OperationDataDefinition(interfaceOperation));
+        operation.setUniqueId(UUID.randomUUID().toString());
+        operation.setImplementation(artifactDefinition);
     }
 
-    private void updateOperationOnInterface(InterfaceDefinition interfaceDefinition, Operation interfaceOperation, String artifactUUID){
+    private void updateExistingOperation(Operation operation, String artifactUUID){
         ArtifactDefinition artifactDefinition = new ArtifactDefinition();
         artifactDefinition.setArtifactUUID(artifactUUID);
         artifactDefinition.setUniqueId(artifactUUID);
         artifactDefinition.setArtifactType(ArtifactTypeEnum.WORKFLOW.getType());
         artifactDefinition.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
-        interfaceOperation.setImplementation(artifactDefinition);
-        interfaceDefinition.getOperations().put(interfaceOperation.getUniqueId(), new OperationDataDefinition(interfaceOperation));
+        operation.setImplementation(artifactDefinition);
     }
 
-    private void updateOperationInputDefs(org.openecomp.sdc.be.model.Component component, Collection<Operation> interfaceOperations) {
-        interfaceOperations.stream().filter(operation -> Objects.nonNull(operation.getInputs()))
-            .forEach(operation -> operation.getInputs().getListToscaDataDefinition()
-                .forEach(inp -> component.getInputs().stream().filter(in -> inp.getInputId().equals(in.getUniqueId()))
-                    .forEach(in -> {
-                        inp.setDefaultValue(in.getDefaultValue());
-                        inp.setValue(in.getValue());
-                        inp.setSchema(in.getSchema());
-                    })));
+    private Either<Boolean, ResponseFormat> lockComponentResult(boolean lock, org.openecomp.sdc.be.model.Component component, String action){
+        if (lock) {
+            Either<Boolean, ResponseFormat> lockResult = lockComponent(component.getUniqueId(), component, action);
+            if (lockResult.isRight()) {
+                LOGGER.debug(FAILED_TO_LOCK_COMPONENT_RESPONSE_IS, component.getName(), lockResult.right().value().getFormattedMessage());
+                titanDao.rollback();
+                return Either.right(lockResult.right().value());
+            }
+        }
+        return Either.left(true);
     }
 
+    public Either<Boolean, ResponseFormat> validateComponentNameAndUpdateInterfaces(org.openecomp.sdc.be.model.Component oldComponent,
+                                                                                    org.openecomp.sdc.be.model.Component newComponent) {
+        if(!oldComponent.getName().equals(newComponent.getName()) ) {
+            Collection<InterfaceDefinition> interfaceDefinitionListFromToscaName = InterfaceUtils
+                    .getInterfaceDefinitionListFromToscaName(oldComponent.getInterfaces().values(),
+                            oldComponent.getName());
+            for (InterfaceDefinition interfaceDefinition : interfaceDefinitionListFromToscaName) {
+
+                Either<InterfaceDefinition, ResponseFormat> interfaceDefinitionResponseEither = updateInterfaceDefinition(oldComponent,
+                                                                    newComponent, interfaceDefinition);
+                if(interfaceDefinitionResponseEither.isRight()) {
+                    return Either.right(interfaceDefinitionResponseEither.right().value());
+                }
+            }
+        }
+        return  Either.left(Boolean.TRUE);
+    }
+    private Either<InterfaceDefinition, ResponseFormat > updateInterfaceDefinition(org.openecomp.sdc.be.model.Component oldComponent,
+                                        org.openecomp.sdc.be.model.Component newComponent,
+                                        InterfaceDefinition interfaceDefinition) {
+                        InterfaceUtils.createInterfaceToscaResourceName(newComponent.getName());
+                interfaceDefinition.setToscaResourceName(InterfaceUtils
+                        .createInterfaceToscaResourceName(newComponent.getName()));
+        try {
+            Either<InterfaceDefinition, StorageOperationStatus> interfaceUpdate = interfaceOperation
+                    .updateInterface(oldComponent.getUniqueId(), interfaceDefinition);
+            if (interfaceUpdate.isRight()) {
+                LOGGER.error("Failed to Update interface {}. Response is {}. ", newComponent.getName(), interfaceUpdate.right().value());
+                titanDao.rollback();
+                return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(interfaceUpdate.right().value(), ComponentTypeEnum.RESOURCE)));
+            }
+        } catch (Exception e) {
+            LOGGER.error("Exception occurred during update interface toscaResourceName  : {}", e);
+            titanDao.rollback();
+            return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
+        }
+        return Either.left( interfaceDefinition);
+    }
+
+    public Either<Map<String, InterfaceDefinition>, ResponseFormat> getAllInterfaceLifecycleTypes() {
+
+        Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfaceLifecycleTypes = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes();
+        if(interfaceLifecycleTypes.isRight()) {
+            return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_LIFECYCLE_TYPES_NOT_FOUND));
+        }
+        interfaceLifecycleTypes.left().value().values().stream().forEach(
+            id -> id.setOperations(id.getOperations().keySet().stream().collect(Collectors.toMap(key -> key.replaceFirst(id.getUniqueId()+".",""), i -> id.getOperations().get(i)))));
+
+        return Either.left(interfaceLifecycleTypes.left().value());
+    }
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
index 4e842928ef..7917a0aa5d 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogic.java
@@ -3984,6 +3984,14 @@ public class ResourceBusinessLogic extends ComponentBusinessLogic {
                 newResource.setDerivedFrom(null);
             }
 
+            Either<Boolean, ResponseFormat> validateAndUpdateInterfacesEither =
+                    interfaceOperationBusinessLogic.validateComponentNameAndUpdateInterfaces(currentResource, newResource);
+            if (validateAndUpdateInterfacesEither.isRight()) {
+                log.error("failed to validate and update Interfaces");
+                rollbackNeeded = true;
+                throw new ComponentException(validateAndUpdateInterfacesEither.right().value());
+            }
+
             Either<Resource, ResponseFormat> dataModelResponse = updateResourceMetadata(resourceIdToUpdate, newResource,
                     user, currentResource, false, true);
             if (dataModelResponse.isRight()) {
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
index 8d4f896d47..e85afdc48f 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/ServiceBusinessLogic.java
@@ -518,7 +518,11 @@ public class ServiceBusinessLogic extends ComponentBusinessLogic {
             log.info("Restricted operation for user: {}, on service: {}", user.getUserId(), currentService.getCreatorUserId());
             return Either.right(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
         }
-
+        Either<Boolean, ResponseFormat> validateAndUpdateInterfacesEither = interfaceOperationBusinessLogic.validateComponentNameAndUpdateInterfaces(currentService, serviceUpdate);
+        if (validateAndUpdateInterfacesEither.isRight()) {
+            log.info("failed to validate and update Interfaces on service {}", currentService.getCreatorUserId());
+            return Either.right(validateAndUpdateInterfacesEither.right().value());
+        }
         Either<Service, ResponseFormat> validationRsponse = validateAndUpdateServiceMetadata(user, currentService, serviceUpdate);
         if (validationRsponse.isRight()) {
             log.info("service update metadata: validations field.");
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java
deleted file mode 100644
index bac23b2133..0000000000
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtils.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright © 2016-2018 European Support Limited
- *
- * 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.
- */
-package org.openecomp.sdc.be.components.utils;
-
-import java.util.Map;
-import java.util.Optional;
-import org.apache.commons.collections.MapUtils;
-import org.openecomp.sdc.be.model.Component;
-import org.openecomp.sdc.be.model.InterfaceDefinition;
-import org.openecomp.sdc.be.model.Operation;
-
-public class InterfaceOperationUtils {
-
-    private InterfaceOperationUtils(){}
-
-    public static final Optional<InterfaceDefinition> getInterfaceDefinitionFromComponentByInterfaceType(Component component, String interfaceType) {
-        if (MapUtils.isEmpty(component.getInterfaces())) {
-            return Optional.empty();
-        }
-        return component.getInterfaces().values().stream().filter(interfaceDefinition -> interfaceDefinition.getType() != null && interfaceDefinition.getType().equals(interfaceType)).findAny();
-    }
-
-    public static final Optional<InterfaceDefinition> getInterfaceDefinitionFromComponentByInterfaceId(Component component, String interfaceId) {
-        if (MapUtils.isEmpty(component.getInterfaces())) {
-            return Optional.empty();
-        }
-        return component.getInterfaces().values().stream().filter(interfaceDefinition -> interfaceDefinition.getUniqueId() != null && interfaceDefinition.getUniqueId().equals(interfaceId)).findAny();
-    }
-
-    public static final Optional<Map.Entry<String, Operation>> getOperationFromInterfaceDefinition(InterfaceDefinition interfaceDefinition, String operationId) {
-        if (MapUtils.isEmpty(interfaceDefinition.getOperationsMap())) {
-            return Optional.empty();
-        }
-        Optional<Map.Entry<String, Operation>> operationMap = interfaceDefinition.getOperationsMap().entrySet().stream().filter(entry -> entry.getValue().getUniqueId().equals(operationId)).findAny();
-        if (operationMap.isPresent()) {
-            return operationMap;
-        }
-        return Optional.empty();
-    }
-
-}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java
index bfb2429a83..7b650e4fad 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidation.java
@@ -16,7 +16,6 @@
 
 package org.openecomp.sdc.be.components.validation;
 
-import fj.data.Either;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -26,11 +25,16 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.regex.Pattern;
-import java.util.stream.Stream;
+import java.util.stream.Collectors;
+
+import fj.data.Either;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.collections.MapUtils;
 import org.apache.commons.lang.StringUtils;
+import org.elasticsearch.common.Strings;
 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
 import org.openecomp.sdc.be.model.InputDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
@@ -44,117 +48,64 @@ import org.springframework.stereotype.Component;
 public class InterfaceOperationValidation {
 
     private static final String TYPE_VALIDATION_REGEX = "^[a-zA-Z]{1,200}$";
+    private static final int DESCRIPTION_MAX_LENGTH = 200;
 
     private static final Logger LOGGER = LoggerFactory.getLogger(InterfaceOperationValidation.class);
 
     public Either<Boolean, ResponseFormat> validateInterfaceOperations(
-        InterfaceDefinition inputInterfaceDefinition, org.openecomp.sdc.be.model.Component component,
-        InterfaceDefinition storedInterfaceDefinition, Map<String, InterfaceDefinition> globalInterfaceTypes, boolean isUpdate) {
-
-        Either<Boolean, ResponseFormat> validateAllowedOperationCountOnLocalInterfaceType =
-            validateAllowedOperationCountOnLocalInterfaceType(inputInterfaceDefinition, storedInterfaceDefinition, globalInterfaceTypes, isUpdate);
-        if(validateAllowedOperationCountOnLocalInterfaceType.isRight()){
-            return validateAllowedOperationCountOnLocalInterfaceType;
-        }
-
-        Either<Boolean, ResponseFormat> validateAllowedOperationsOnGlobalInterfaceType = validateAllowedOperationsOnGlobalInterfaceType(inputInterfaceDefinition, globalInterfaceTypes);
-        if(validateAllowedOperationsOnGlobalInterfaceType.isRight()){
-            return validateAllowedOperationsOnGlobalInterfaceType;
-        }
+        Collection<Operation> interfaceOperations, org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
 
-        Either<Boolean, ResponseFormat> validateOperationNameUniqueness = validateOperationNameUniquenessInCollection(inputInterfaceDefinition.getOperationsMap().values());
-        if(validateOperationNameUniqueness.isRight()){
-            return validateOperationNameUniqueness;
-        }
-
-        for(Operation interfaceOperation : inputInterfaceDefinition.getOperationsMap().values()) {
+        for(Operation interfaceOperation : interfaceOperations) {
             Either<Boolean, ResponseFormat> interfaceOperationValidatorResponse = validateInterfaceOperation(
-                interfaceOperation, storedInterfaceDefinition, component, isUpdate);
+                interfaceOperation, component, isUpdate);
             if (interfaceOperationValidatorResponse.isRight()) {
                 return interfaceOperationValidatorResponse;
             }
         }
-
-        return Either.left(Boolean.TRUE);
-    }
-
-    private Either<Boolean, ResponseFormat> validateOperationNameUniquenessInCollection(Collection<Operation> operationList){
-        HashSet<String> operationNames = new HashSet<>();
-        for (Operation operation : operationList) {
-            if(!operationNames.add(operation.getName())){
-                return Either.right(getResponseFormatManager().getResponseFormat(ActionStatus.INTERFACE_OPERATION_NAME_ALREADY_IN_USE, operation.getName()));
-            }
-        }
-        return Either.left(Boolean.TRUE);
-    }
-
-    private Either<Boolean, ResponseFormat> validateAllowedOperationCountOnLocalInterfaceType(InterfaceDefinition inputInterfaceDefinition,
-        InterfaceDefinition storedInterfaceDefinition, Map<String, InterfaceDefinition> globalInterfaceTypes, boolean isUpdate){
-
-        boolean isInterfaceTypeExistInGlobalType = globalInterfaceTypes.values().stream().map(InterfaceDefinition::getType)
-            .anyMatch(type -> type.equalsIgnoreCase(inputInterfaceDefinition.getType()));
-        if(!isInterfaceTypeExistInGlobalType && (inputInterfaceDefinition.getOperations().size() > 1 || (!isUpdate && storedInterfaceDefinition != null && storedInterfaceDefinition.getType().equalsIgnoreCase(inputInterfaceDefinition.getType())))){
-            return Either.right(getResponseFormatManager().getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_LOCAL_TYPE, inputInterfaceDefinition.getType()));
-        }
-
-        return Either.left(Boolean.TRUE);
-    }
-
-    private Either<Boolean, ResponseFormat> validateAllowedOperationsOnGlobalInterfaceType(InterfaceDefinition interfaceDefinition,
-        Map<String, InterfaceDefinition> globalInterfaceTypes) {
-
-        if(globalInterfaceTypes != null){
-            boolean isOperationValidOnGlobalInterfaceType = Stream.of(interfaceDefinition)
-                .filter(interfaceDef -> globalInterfaceTypes.values().stream().anyMatch(interfaceDef1 -> interfaceDef1.getType().equalsIgnoreCase(interfaceDef.getType())))
-                .flatMap(interfaceDef -> interfaceDef.getOperationsMap().values().stream().map(Operation::getName))
-                .allMatch(operationName -> globalInterfaceTypes.values().stream()
-                    .flatMap(interfaceDef -> interfaceDef.getOperationsMap().keySet().stream().map(operation -> operation))
-                    .anyMatch(opName -> opName.equalsIgnoreCase(operationName)));
-            if(!isOperationValidOnGlobalInterfaceType){
-                return Either.right(getResponseFormatManager().getResponseFormat(ActionStatus.INTERFACE_OPERATION_INVALID_FOR_GLOBAL_TYPE, interfaceDefinition.getType()));
-            }
-        }
         return Either.left(Boolean.TRUE);
     }
 
     private Either<Boolean, ResponseFormat> validateInterfaceOperation(Operation interfaceOperation,
-        InterfaceDefinition interfaceDefinition,
         org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
-
         ResponseFormatManager responseFormatManager = getResponseFormatManager();
+
         Either<Boolean, ResponseFormat> interfaceOperationTypeResponse = isInterfaceOperationTypeValid(interfaceOperation,
-            responseFormatManager, interfaceDefinition, isUpdate);
+            responseFormatManager, component, isUpdate);
         if (interfaceOperationTypeResponse.isRight()) {
             return Either.right(interfaceOperationTypeResponse.right().value());
         }
 
-        if(null != interfaceOperation.getInputs()) {
-            Either<Boolean, ResponseFormat> inputParametersResponse = validateInputParameters(interfaceOperation, responseFormatManager);
-            if (inputParametersResponse.isRight()) {
-                return Either.right(inputParametersResponse.right().value());
-            }
+        Either<Boolean, ResponseFormat> descriptionResponseEither = isValidDescription(responseFormatManager,
+            interfaceOperation.getDescription());
+        if (descriptionResponseEither.isRight()) {
+            return Either.right(descriptionResponseEither.right().value());
+        }
 
-            Either<Boolean, ResponseFormat> inputPropertyExistInComponent = validateInputPropertyExistInComponent(interfaceOperation,
-                component, responseFormatManager);
-            if(inputPropertyExistInComponent.isRight()) {
-                return Either.right(inputPropertyExistInComponent.right().value());
+        Either<Boolean, ResponseFormat> inputPropertyExistInComponent = validateInputPropertyExistInComponent(interfaceOperation,
+                component.getInputs(), responseFormatManager);
+        if(inputPropertyExistInComponent.isRight()) {
+            return Either.right(inputPropertyExistInComponent.right().value());
 
-            }
         }
 
-        if(null != interfaceOperation.getOutputs()) {
-            Either<Boolean, ResponseFormat> outputParametersResponse = validateOutputParameters(interfaceOperation, responseFormatManager);
-            if (outputParametersResponse.isRight()) {
-                return Either.right(outputParametersResponse.right().value());
-            }
+        Either<Boolean, ResponseFormat> inputParametersResponse = validateInputParameters(interfaceOperation,
+            responseFormatManager);
+        if(inputParametersResponse.isRight()) {
+            return Either.right(inputParametersResponse.right().value());
+        }
+
+        Either<Boolean, ResponseFormat> outputParametersResponse = validateOutputParameters(interfaceOperation,
+            responseFormatManager);
+        if(outputParametersResponse.isRight()) {
+            return Either.right(outputParametersResponse.right().value());
         }
 
         return Either.left(Boolean.TRUE);
     }
 
     private Either<Boolean, ResponseFormat> isInterfaceOperationTypeValid(Operation interfaceOperation,
-        ResponseFormatManager responseFormatManager, InterfaceDefinition interfaceDefinition,
-        boolean isUpdate) {
+        ResponseFormatManager responseFormatManager,
+        org.openecomp.sdc.be.model.Component component, boolean isUpdate) {
 
         Either<Boolean, ResponseFormat> operationTypeEmptyEither =
             isOperationTypeEmpty(responseFormatManager, interfaceOperation.getName());
@@ -169,7 +120,7 @@ public class InterfaceOperationValidation {
         }
 
         Either<Boolean, ResponseFormat> operationTypeUniqueResponse = validateOperationTypeUnique(interfaceOperation,
-            interfaceDefinition, isUpdate );
+            component, isUpdate );
         if(operationTypeUniqueResponse.isRight()) {
             return Either.right(operationTypeUniqueResponse.right().value());
         }
@@ -205,21 +156,42 @@ public class InterfaceOperationValidation {
         return Either.left(Boolean.TRUE);
     }
 
+    private Either<Boolean, ResponseFormat> isValidDescription(ResponseFormatManager responseFormatManager,
+        String description) {
+        if (!Strings.isNullOrEmpty(description) && description.length() > DESCRIPTION_MAX_LENGTH) {
+            LOGGER.error("Interface Operation description {} is invalid, maximum 200 characters allowed", description);
+            ResponseFormat errorResponse = responseFormatManager.getResponseFormat(ActionStatus
+                .INTERFACE_OPERATION_DESCRIPTION_MAX_LENGTH, description);
+            return Either.right(errorResponse);
+        }
+        return Either.left(Boolean.TRUE);
+    }
+
     private boolean isValidOperationType(String operationType) {
         return Pattern.matches(TYPE_VALIDATION_REGEX, operationType);
     }
 
     private Either<Boolean, ResponseFormat> validateOperationTypeUnique(
-        Operation interfaceOperation, InterfaceDefinition interfaceDefinition,
+        Operation interfaceOperation,
+        org.openecomp.sdc.be.model.Component component,
         boolean isUpdate) {
         boolean isOperationTypeUnique = false;
 
-        if(interfaceDefinition == null || CollectionUtils.isEmpty(interfaceDefinition.getOperationsMap().values())){
+        Map<String, InterfaceDefinition> interfaceDefinitionMap = component.getInterfaces();
+        if(interfaceDefinitionMap.isEmpty()){
+            return Either.left(true);
+        }
+
+        Collection<Operation> allOperations = interfaceDefinitionMap.values().stream()
+            .filter(a -> MapUtils.isNotEmpty(a.getOperationsMap()))
+            .map(a -> a.getOperationsMap().values()).flatMap(Collection::stream)
+            .collect(Collectors.toList());
+        if(CollectionUtils.isEmpty(allOperations)){
             return Either.left(true);
         }
 
         Map<String, String> operationTypes = new HashMap<>();
-        interfaceDefinition.getOperationsMap().values().forEach(operationType -> operationTypes.put(operationType.getUniqueId(), operationType.getName()));
+        allOperations.forEach(operationType -> operationTypes.put(operationType.getUniqueId(), operationType.getName()));
 
         if (!operationTypes.values().contains(interfaceOperation.getName())){
             isOperationTypeUnique = true;
@@ -234,7 +206,6 @@ public class InterfaceOperationValidation {
 
         return Either.left(isOperationTypeUnique);
     }
-
     private Either<Boolean, ResponseFormat> validateInputParameters(Operation interfaceOperation,
         ResponseFormatManager responseFormatManager) {
         if (isInputParameterNameEmpty(interfaceOperation)) {
@@ -313,15 +284,19 @@ public class InterfaceOperationValidation {
     }
 
     private  Either<Boolean, ResponseFormat> validateInputPropertyExistInComponent(Operation operation,
-        org.openecomp.sdc.be.model.Component component,
-        ResponseFormatManager responseFormatManager) {
+                                                    List<InputDefinition> inputs,
+                                                    ResponseFormatManager responseFormatManager) {
+        ListDataDefinition<OperationInputDefinition> inputDefinitionListDataDefinition = operation.getInputs();
+        if (inputDefinitionListDataDefinition == null) {
+            return Either.left(Boolean.TRUE);
+        }
+        List<OperationInputDefinition> inputListToscaDataDefinition = inputDefinitionListDataDefinition.getListToscaDataDefinition();
 
-        List<OperationInputDefinition> inputListToscaDataDefinition = operation.getInputs().getListToscaDataDefinition();
         for(OperationInputDefinition inputDefinition : inputListToscaDataDefinition ) {
-            if(!validateInputExistsInComponent(inputDefinition, component.getInputs())) {
-                String missingPropertyName = inputDefinition.getInputId().contains(".") ? inputDefinition.getInputId().substring(inputDefinition.getInputId().indexOf('.') + 1) : inputDefinition.getInputId();
+            if(!validateInputExistsInComponent(inputDefinition, inputs)) {
+                String missingPropertyName = inputDefinition.getInputId().contains(".") ? inputDefinition.getInputId().substring(inputDefinition.getInputId().indexOf(".") + 1) : inputDefinition.getInputId();
                 LOGGER.error("Interface operation input property {} not found in component input properties", missingPropertyName);
-                ResponseFormat inputResponse = responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT, missingPropertyName, component.getComponentType().getValue());
+                ResponseFormat inputResponse = responseFormatManager.getResponseFormat(ActionStatus.INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT, missingPropertyName);
                 return Either.right(inputResponse);
             }
         }
@@ -329,14 +304,14 @@ public class InterfaceOperationValidation {
     }
 
     private boolean validateInputExistsInComponent(OperationInputDefinition input,
-        List<InputDefinition> inputs) {
+                                                   List<InputDefinition> inputs) {
         return inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(input.getInputId()))
-            || (input.getInputId().contains(".")
-            && inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(
-            input.getInputId().substring(0, input.getInputId().lastIndexOf('.'))))) ;
+                || ((input.getInputId().contains(".")
+                && inputs.stream().anyMatch(inp -> inp.getUniqueId().equals(
+                    input.getInputId().substring(0, input.getInputId().lastIndexOf(".")))))) ;
     }
 
-    protected ResponseFormatManager getResponseFormatManager() {
+    private ResponseFormatManager getResponseFormatManager() {
         return ResponseFormatManager.getInstance();
     }
 
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverter.java b/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverter.java
new file mode 100644
index 0000000000..7fbc56a624
--- /dev/null
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverter.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * 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.
+ */
+
+package org.openecomp.sdc.be.datamodel.utils;
+
+import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationParamDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition;
+import org.openecomp.sdc.be.model.Operation;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class InterfaceUIDataConverter {
+
+  private InterfaceUIDataConverter () {
+
+  }
+  public static Operation convertInterfaceDataToOperationData(InterfaceOperationDataDefinition interfaceOperation){
+
+    ListDataDefinition<InterfaceOperationParamDataDefinition> inputParams = interfaceOperation.getInputParams();
+    ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>();
+    if (inputParams != null) {
+      List<OperationInputDefinition> inputList = inputParams.getListToscaDataDefinition().stream()
+              .map(interfaceOperationParamDataDefinition -> new OperationInputDefinition(
+                      interfaceOperationParamDataDefinition.getName(),
+                      interfaceOperationParamDataDefinition.getProperty(),
+                      interfaceOperationParamDataDefinition.getMandatory() == null ? false : interfaceOperationParamDataDefinition.getMandatory(),
+                      interfaceOperationParamDataDefinition.getType()
+                      )).collect(Collectors.toList());
+      inputList.forEach(inputs::add);
+    }
+    ListDataDefinition<InterfaceOperationParamDataDefinition> outputParams = interfaceOperation.getOutputParams();
+    ListDataDefinition<OperationOutputDefinition> outputs = new ListDataDefinition<>();
+    if(outputParams != null) {
+      List<OperationOutputDefinition> outputList = outputParams.getListToscaDataDefinition().stream()
+              .map(interfaceOperationParamDataDefinition -> new OperationOutputDefinition(
+                      interfaceOperationParamDataDefinition.getName(),
+                      interfaceOperationParamDataDefinition.getMandatory() == null ? false : interfaceOperationParamDataDefinition.getMandatory(),
+                      interfaceOperationParamDataDefinition.getType()
+                      )).collect(Collectors.toList());
+      outputList.forEach(outputs::add);
+    }
+
+    Operation operationData = new Operation();
+    operationData.setDescription(interfaceOperation.getDescription());
+    operationData.setName(interfaceOperation.getOperationType());
+    operationData.setUniqueId(interfaceOperation.getUniqueId());
+    operationData.setInputs(inputs);
+    operationData.setOutputs(outputs);
+    operationData.setWorkflowId(interfaceOperation.getWorkflowId());
+    operationData.setWorkflowVersionId(interfaceOperation.getWorkflowVersionId());
+    operationData.setWorkflowAssociationType(interfaceOperation.getWorkflowAssociationType());
+
+    return operationData;
+  }
+
+  public static InterfaceOperationDataDefinition convertOperationDataToInterfaceData(Operation operationData){
+    ListDataDefinition<OperationInputDefinition> inputs = operationData.getInputs();
+    List<InterfaceOperationParamDataDefinition> inputParamList = inputs.getListToscaDataDefinition().stream()
+            .map(operationInputDefinition -> new InterfaceOperationParamDataDefinition(operationInputDefinition.getName(),
+                    operationInputDefinition.getInputId(),
+                    operationInputDefinition.isRequired(),
+                    operationInputDefinition.getType())).collect(
+            Collectors.toList());
+    ListDataDefinition<InterfaceOperationParamDataDefinition> inputParams = new ListDataDefinition<>();
+    inputParamList.forEach(inputParams::add);
+
+    ListDataDefinition<OperationOutputDefinition> outputs = operationData.getOutputs();
+    List<InterfaceOperationParamDataDefinition> outputParamList = outputs.getListToscaDataDefinition()
+            .stream().map(operationOutputDefinition -> new InterfaceOperationParamDataDefinition(operationOutputDefinition.getName(),
+                    operationOutputDefinition.isRequired(),
+                    operationOutputDefinition.getType())).collect(Collectors.toList());
+    ListDataDefinition<InterfaceOperationParamDataDefinition> outputParams = new ListDataDefinition<>();
+    outputParamList.forEach(outputParams::add);
+
+    InterfaceOperationDataDefinition interfaceOperationDataDefinition = new InterfaceOperationDataDefinition();
+    interfaceOperationDataDefinition.setUniqueId(operationData.getUniqueId());
+    interfaceOperationDataDefinition.setOperationType(operationData.getName());
+    interfaceOperationDataDefinition.setDescription(operationData.getDescription());
+    interfaceOperationDataDefinition.setInputParams(inputParams);
+    interfaceOperationDataDefinition.setOutputParams(outputParams);
+    interfaceOperationDataDefinition.setArtifactUUID(operationData.getImplementation().getArtifactUUID());
+    interfaceOperationDataDefinition.setWorkflowId(operationData.getWorkflowId());
+    interfaceOperationDataDefinition.setWorkflowVersionId(operationData.getWorkflowVersionId());
+    interfaceOperationDataDefinition.setWorkflowAssociationType(operationData.getWorkflowAssociationType());
+
+    return interfaceOperationDataDefinition;
+  }
+
+}
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java
index 31bc165ee0..03c5e0fbf1 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/externalapi/servlet/ArtifactExternalServlet.java
@@ -98,7 +98,7 @@ public class ArtifactExternalServlet extends AbstractValidationsServlet {
     private static String startLog = "Start handle request of ";
 
     @POST
-    @Path("/{assetType}/{uuid}/interfaces/{interfaceUUID}/operations/{operationUUID}/artifacts/{artifactUUID}")
+    @Path("/{assetType}/{uuid}/interfaces/{operationUUID}/artifacts/{artifactUUID}")
     @Produces(MediaType.APPLICATION_JSON)
     @ApiOperation(value = "uploads of artifact to VF operation workflow", httpMethod = "POST", notes = "uploads of artifact to VF operation workflow")
     @ApiResponses(value = {
@@ -127,7 +127,6 @@ public class ArtifactExternalServlet extends AbstractValidationsServlet {
             @ApiParam(value = "The username and password", required = true) @HeaderParam(value = Constants.AUTHORIZATION_HEADER) String authorization,
             @ApiParam(value = "Asset type") @PathParam("assetType") String assetType,
             @ApiParam(value = "The uuid of the asset as published in the metadata", required = true)@PathParam("uuid") final String uuid,
-            @ApiParam(value = "The uuid of the interface", required = true)@PathParam("interfaceUUID") final String interfaceUUID,
             @ApiParam(value = "The uuid of the operation", required = true)@PathParam("operationUUID") final String operationUUID,
             @ApiParam(value = "The uuid of the artifact", required = true)@PathParam("artifactUUID") final String artifactUUID,
             @ApiParam( hidden = true) String data) {
@@ -155,7 +154,7 @@ public class ArtifactExternalServlet extends AbstractValidationsServlet {
                 ArtifactsBusinessLogic artifactsLogic = getArtifactBL(context);
                 Either<ArtifactDefinition, ResponseFormat> uploadArtifactEither = artifactsLogic
                         .updateArtifactOnInterfaceOperationByResourceUUID(data, request, ComponentTypeEnum
-                                        .findByParamName(assetType), uuid, interfaceUUID, operationUUID, artifactUUID,
+                                        .findByParamName(assetType), uuid,  artifactUUID, operationUUID,
                         resourceCommonInfo, artifactsLogic.new ArtifactOperationInfo(true, false, ArtifactOperationEnum.UPDATE));
                 if (uploadArtifactEither.isRight()) {
                     log.debug(FAILED_TO_UPDATE_ARTIFACT);
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java
index af6976d7b3..815f9763f9 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/InterfaceOperationServlet.java
@@ -16,7 +16,6 @@
 
 package org.openecomp.sdc.be.servlets;
 
-import com.google.common.collect.ImmutableMap;
 import com.jcabi.aspects.Loggable;
 import fj.data.Either;
 import io.swagger.annotations.Api;
@@ -24,11 +23,8 @@ import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
 import io.swagger.annotations.ApiResponse;
 import io.swagger.annotations.ApiResponses;
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
+import java.util.Optional;
+import java.util.UUID;
 import javax.inject.Singleton;
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
@@ -47,9 +43,10 @@ import javax.ws.rs.core.Response;
 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
 import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.datamodel.utils.InterfaceUIDataConverter;
+import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
-import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
-import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.Operation;
 import org.openecomp.sdc.be.model.User;
 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
@@ -59,10 +56,10 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Loggable(prepend = true, value = Loggable.DEBUG, trim = false)
-@Path("/v1/catalog")
+@Path("/v1/catalog/{componentType}/{componentId}/interfaceOperations")
 @Consumes(MediaType.APPLICATION_JSON)
 @Produces(MediaType.APPLICATION_JSON)
-@Api(value = "Interface Operation Servlet", description = "Interface Operation Servlet")
+@Api(value = "Interface Operation", description = "Interface Operation Servlet")
 @Singleton
 public class InterfaceOperationServlet extends AbstractValidationsServlet {
 
@@ -71,154 +68,72 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
   @POST
   @Consumes(MediaType.APPLICATION_JSON)
   @Produces(MediaType.APPLICATION_JSON)
-  @Path("/resources/{resourceId}/interfaceOperations")
-  @ApiOperation(value = "Create Interface Operations on Resource", httpMethod = "POST", notes = "Create Interface Operations on Resource", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Create Interface Operations on Resource"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Resource not found"),
-      @ApiResponse(code = 409, message = "Interface Operation already exist")})
-  public Response createInterfaceOperationsOnResource(
-      @ApiParam(value = "Interface Operations to create", required = true) String data,
-      @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return createOrUpdate(data, ComponentTypeEnum.RESOURCE, resourceId, request, userId, false);
-  }
-
-  @PUT
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/resources/{resourceId}/interfaceOperations")
-  @ApiOperation(value = "Update Interface Operations on Resource", httpMethod = "PUT", notes = "Update Interface Operations on Resource", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Update Interface Operations on Resource"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+  @Path("/")
+  @ApiOperation(value = "Create Interface Operation", httpMethod = "POST", notes = "Create Interface Operation", response = InterfaceOperationDataDefinition.class)
+  @ApiResponses(value = {@ApiResponse(code = 201, message = "Create Interface Operation"),
       @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Resource not found")})
-  public Response updateInterfaceOperationsOnResource(
-      @ApiParam(value = "Interface Operations to update", required = true) String data,
-      @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return createOrUpdate(data, ComponentTypeEnum.RESOURCE, resourceId, request, userId, true);
-  }
-
-  @DELETE
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/resources/{resourceId}/interfaces/{interfaceId}/operations/{operationIds}")
-  @ApiOperation(value = "Delete Interface Operations from Resource", httpMethod = "DELETE", notes = "Delete Interface Operations from Resource", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Delete Interface Operations from Resource"),
       @ApiResponse(code = 400, message = "Invalid content / Missing content"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Resource not found")})
-  public Response deleteInterfaceOperationsFromResource(
-      @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
-      @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
-      @ApiParam(value = "Comma seperated value of Operation Ids") @PathParam("operationIds") String operationIds,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return delete(interfaceId, operationIds, resourceId, request, userId);
-  }
-
-  @GET
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/resources/{resourceId}/interfaces/{interfaceId}/operations/{operationIds}")
-  @ApiOperation(value = "Get Interface Operations from Resource", httpMethod = "GET", notes = "GET Interface Operations from Resource", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Delete Interface Operations from Resource"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Resource not found")})
-  public Response getInterfaceOperationsFromResource(
-      @ApiParam(value = "Resource Id") @PathParam("resourceId") String resourceId,
-      @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
-      @ApiParam(value = "Comma seperated value of operationIds") @PathParam("operationIds") String operationIds,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return get(interfaceId, operationIds, resourceId, request, userId);
-  }
-
-  @POST
-  @Consumes(MediaType.APPLICATION_JSON)
-  @Produces(MediaType.APPLICATION_JSON)
-  @Path("/services/{serviceId}/interfaceOperations")
-  @ApiOperation(value = "Create Interface Operations on Service", httpMethod = "POST", notes = "Create Interface Operations on Service", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Create Interface Operations on Service"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
-      @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Service not found"),
       @ApiResponse(code = 409, message = "Interface Operation already exist")})
-  public Response createInterfaceOperationsOnService(
-      @ApiParam(value = "Interface Operations to create", required = true) String data,
-      @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return createOrUpdate(data, ComponentTypeEnum.SERVICE, serviceId, request, userId, false);
+  public Response createInterfaceOperation(
+      @ApiParam(value = "Interface Operation to create", required = true) String data,
+      @ApiParam(value = "Component type") @PathParam("componentType") String componentType,
+      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
+      @Context final HttpServletRequest request,
+      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
+    return createOrUpdate(data, componentType ,componentId, request, userId, false);
   }
 
   @PUT
   @Consumes(MediaType.APPLICATION_JSON)
   @Produces(MediaType.APPLICATION_JSON)
-  @Path("/services/{serviceId}/interfaceOperations")
-  @ApiOperation(value = "Update Interface Operations on Service", httpMethod = "PUT", notes = "Update Interface Operations on Service", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Update Interface Operations on Service"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+  @Path("/")
+  @ApiOperation(value = "Update Interface Operation", httpMethod = "PUT", notes = "Update Interface Operation", response = InterfaceOperationDataDefinition.class)
+  @ApiResponses(value = {@ApiResponse(code = 201, message = "Update Interface Operation"),
       @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Service not found")})
-  public Response updateInterfaceOperationsOnService(
-      @ApiParam(value = "Interface Operations to update", required = true) String data,
-      @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return createOrUpdate(data, ComponentTypeEnum.SERVICE, serviceId, request, userId, true);
+      @ApiResponse(code = 400, message = "Invalid content / Missing content")})
+  public Response updateInterfaceOperation(
+      @ApiParam(value = "Interface Operation to update", required = true) String data,
+      @ApiParam(value = "Component type") @PathParam("componentType") String componentType,
+      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
+      @Context final HttpServletRequest request,
+      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
+    return createOrUpdate(data, componentType,componentId, request, userId, true);
   }
 
   @DELETE
   @Consumes(MediaType.APPLICATION_JSON)
   @Produces(MediaType.APPLICATION_JSON)
-  @Path("/services/{serviceId}/interfaces/{interfaceId}/operations/{operationIds}")
-  @ApiOperation(value = "Delete Interface Operations from Service", httpMethod = "DELETE", notes = "Delete Interface Operations from Service", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Delete Interface Operations from Service"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+  @Path("/{interfaceOperationId}")
+  @ApiOperation(value = "Delete Interface Operation", httpMethod = "DELETE", notes = "Delete Interface Operation", response = InterfaceOperationDataDefinition.class)
+  @ApiResponses(value = {@ApiResponse(code = 201, message = "Delete Interface Operation"),
       @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Service not found")})
-  public Response deleteInterfaceOperationsFromService(
-      @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
-      @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
-      @ApiParam(value = "Comma seperated value of Operation Ids") @PathParam("operationIds") String operationIds,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return delete(interfaceId, operationIds, serviceId, request, userId);
+      @ApiResponse(code = 400, message = "Invalid content / Missing content")})
+  public Response deleteInterfaceOperation(
+      @ApiParam(value = "Interface Operation Id") @PathParam("interfaceOperationId") String interfaceOperationId,
+      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
+      @Context final HttpServletRequest request,
+      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
+    return delete(interfaceOperationId, componentId, request, userId);
   }
 
   @GET
   @Consumes(MediaType.APPLICATION_JSON)
   @Produces(MediaType.APPLICATION_JSON)
-  @Path("/services/{serviceId}/interfaces/{interfaceId}/operations/{operationIds}")
-  @ApiOperation(value = "Get Interface Operations from Service", httpMethod = "GET", notes = "GET Interface Operations from Service", response = Response.class)
-  @ApiResponses(value = {
-      @ApiResponse(code = 201, message = "Get Interface Operations from Service"),
-      @ApiResponse(code = 400, message = "Invalid content / Missing content"),
+  @Path("/{interfaceOperationId}")
+  @ApiOperation(value = "Get Interface Operation", httpMethod = "GET", notes = "GET Interface Operation", response = InterfaceOperationDataDefinition.class)
+  @ApiResponses(value = {@ApiResponse(code = 201, message = "Get Interface Operation"),
       @ApiResponse(code = 403, message = "Restricted operation"),
-      @ApiResponse(code = 404, message = "Service not found")})
-  public Response getInterfaceOperationsFromService(
-      @ApiParam(value = "Service Id") @PathParam("serviceId") String serviceId,
-      @ApiParam(value = "Interface Id") @PathParam("interfaceId") String interfaceId,
-      @ApiParam(value = "Comma seperated value of operationIds") @PathParam("operationIds") String operationIds,
-      @HeaderParam(value = Constants.USER_ID_HEADER) String userId,
-      @Context final HttpServletRequest request) {
-    return get(interfaceId, operationIds, serviceId, request, userId);
+      @ApiResponse(code = 400, message = "Invalid content / Missing content")})
+  public Response getInterfaceOperation(
+      @ApiParam(value = "Interface Operation Id") @PathParam("interfaceOperationId") String interfaceOperationId,
+      @ApiParam(value = "Component Id") @PathParam("componentId") String componentId,
+      @Context final HttpServletRequest request,
+      @HeaderParam(value = Constants.USER_ID_HEADER) String userId) {
+
+    return get(interfaceOperationId, componentId, request, userId);
   }
 
-  private Response get (String interfaceId, String operationIds,  String componentId, HttpServletRequest request, String userId){
+  private Response get (String interfaceOperationId,  String componentId, HttpServletRequest request, String userId){
     ServletContext context = request.getSession().getServletContext();
     String url = request.getMethod() + " " + request.getRequestURI();
 
@@ -230,14 +145,15 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
       String componentIdLower = componentId.toLowerCase();
       InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 
-      List<String> operationsToGet = Stream.of(operationIds.split(",")).map(String::trim).collect(Collectors.toList());
-      Either<List<InterfaceDefinition>, ResponseFormat> actionResponse = businessLogic.getInterfaceOperation(componentIdLower, interfaceId, operationsToGet, modifier, true);
+      Either<Operation, ResponseFormat> actionResponse = businessLogic.getInterfaceOperation(componentIdLower, interfaceOperationId, modifier, true);
       if (actionResponse.isRight()) {
         log.error("failed to get interface operation");
         return buildErrorResponse(actionResponse.right().value());
       }
 
-      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), getFormattedResponse(actionResponse.left().value()));
+      InterfaceOperationDataDefinition interfaceOperationDataDefinition = InterfaceUIDataConverter.convertOperationDataToInterfaceData(actionResponse.left().value());
+      Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
+      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
     }
     catch (Exception e) {
       BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Get Component interface operations");
@@ -246,7 +162,8 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
     }
   }
 
-  private Response delete (String interfaceId, String operationIds, String componentId, HttpServletRequest request, String userId){
+  private Response delete (String interfaceOperationId, String componentId, HttpServletRequest
+      request, String userId){
 
     ServletContext context = request.getSession().getServletContext();
     String url = request.getMethod() + " " + request.getRequestURI();
@@ -259,14 +176,15 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
       String componentIdLower = componentId.toLowerCase();
       InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 
-      List<String> operationsToDelete = Stream.of(operationIds.split(",")).map(String::trim).collect(Collectors.toList());
-      Either<List<InterfaceDefinition>, ResponseFormat> actionResponse = businessLogic.deleteInterfaceOperation(componentIdLower, interfaceId, operationsToDelete, modifier, true);
+      Either<Operation, ResponseFormat> actionResponse = businessLogic.deleteInterfaceOperation(componentIdLower, interfaceOperationId, modifier, true);
       if (actionResponse.isRight()) {
         log.error("failed to delete interface operation");
         return buildErrorResponse(actionResponse.right().value());
       }
 
-      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), getFormattedResponse(actionResponse.left().value()));
+      InterfaceOperationDataDefinition interfaceOperationDataDefinition = InterfaceUIDataConverter.convertOperationDataToInterfaceData(actionResponse.left().value());
+      Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
+      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
     }
     catch (Exception e) {
       BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Delete Interface Operation");
@@ -275,7 +193,7 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
     }
   }
 
-  private Response createOrUpdate (String data, ComponentTypeEnum componentType, String componentId, HttpServletRequest request, String userId, boolean isUpdate) {
+  private Response createOrUpdate (String data, String componentType, String componentId, HttpServletRequest request, String userId, boolean isUpdate) {
     ServletContext context = request.getSession().getServletContext();
     String url = request.getMethod() + " " + request.getRequestURI();
 
@@ -287,12 +205,12 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
       String componentIdLower = componentId.toLowerCase();
       InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context);
 
-      List<InterfaceDefinition> mappedInterfaceData = getMappedInterfaceData(data, modifier, componentType);
-      Either<List<InterfaceDefinition>, ResponseFormat> actionResponse ;
+      Operation operation = getMappedOperationData(data, isUpdate, modifier, ComponentTypeEnum.findByParamName(componentType));
+      Either<Operation, ResponseFormat> actionResponse ;
       if (isUpdate) {
-        actionResponse = businessLogic.updateInterfaceOperation(componentIdLower, mappedInterfaceData, modifier, true);
+        actionResponse = businessLogic.updateInterfaceOperation(componentIdLower, operation, modifier, true);
       } else {
-        actionResponse = businessLogic.createInterfaceOperation(componentIdLower, mappedInterfaceData, modifier, true);
+        actionResponse = businessLogic.createInterfaceOperation(componentIdLower, operation, modifier, true);
       }
 
       if (actionResponse.isRight()) {
@@ -300,7 +218,9 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
         return buildErrorResponse(actionResponse.right().value());
       }
 
-      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), getFormattedResponse(actionResponse.left().value()));
+      InterfaceOperationDataDefinition interfaceOperationDataDefinition = InterfaceUIDataConverter.convertOperationDataToInterfaceData(actionResponse.left().value());
+      Object result = RepresentationUtils.toFilteredRepresentation(interfaceOperationDataDefinition);
+      return buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), result);
     }
     catch (Exception e) {
       BeEcompErrorManager.getInstance().logBeRestApiGeneralError("Interface Operation Creation or update");
@@ -309,16 +229,16 @@ public class InterfaceOperationServlet extends AbstractValidationsServlet {
     }
   }
 
-  private List<InterfaceDefinition> getMappedInterfaceData(String inputJson, User user, ComponentTypeEnum componentTypeEnum){
-    Either<UiComponentDataTransfer, ResponseFormat> uiComponentEither = getComponentsUtils()
-            .convertJsonToObjectUsingObjectMapper(inputJson, user, UiComponentDataTransfer.class, AuditingActionEnum.CREATE_RESOURCE,
-                    componentTypeEnum);
-    return uiComponentEither.left().value().getInterfaces().values().stream().collect(Collectors.toList());
-  }
-
-  private Object getFormattedResponse(List<InterfaceDefinition> interfaceDefinitions) throws IOException {
-    Map<String, List<InterfaceDefinition>> allInterfaces = ImmutableMap.of(JsonPresentationFields.INTERFACES.getPresentation(), interfaceDefinitions);
-    return RepresentationUtils.toFilteredRepresentation(allInterfaces);
+  private Operation getMappedOperationData(String inputJson, boolean isUpdate, User user, ComponentTypeEnum componentTypeEnum){
+    Either<UiComponentDataTransfer, ResponseFormat> uiComponentEither = getComponentsUtils().convertJsonToObjectUsingObjectMapper(inputJson, user, UiComponentDataTransfer.class, AuditingActionEnum.CREATE_RESOURCE, componentTypeEnum);
+    Optional<InterfaceOperationDataDefinition> opDef = uiComponentEither.left().value().getInterfaceOperations().values().stream().findFirst();
+    InterfaceOperationDataDefinition interfaceOperationDataDefinition = new InterfaceOperationDataDefinition();
+    if(opDef.isPresent()) {
+      interfaceOperationDataDefinition = opDef.get();
+      if(!isUpdate)
+        interfaceOperationDataDefinition.setUniqueId(UUID.randomUUID().toString());
+    }
+    return InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperationDataDefinition);
   }
 
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java
index 239c0421a1..dbdfaa9897 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/RepresentationUtils.java
@@ -32,22 +32,20 @@ import com.google.common.collect.ImmutableMap;
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
 import org.openecomp.sdc.be.config.BeEcompErrorManager;
+import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition;
 import org.openecomp.sdc.be.datatypes.tosca.ToscaDataDefinition;
 import org.openecomp.sdc.be.model.ArtifactDefinition;
 import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.Operation;
 import org.openecomp.sdc.be.model.Resource;
 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
 import org.openecomp.sdc.common.api.Constants;
 import org.openecomp.sdc.common.log.wrappers.Logger;
 
+import java.io.IOException;
+import java.util.*;
+
 public class RepresentationUtils {
 
     private static final Logger log = Logger.getLogger(RepresentationUtils.class);
@@ -190,8 +188,11 @@ public class RepresentationUtils {
                     .put(ArrayList.class,IsEmptyFilterMixIn.class)
                     .put(HashSet.class,IsEmptyFilterMixIn.class)
                     .put(InterfaceDefinition.class,IsEmptyFilterMixIn.class)
+                    .put(Operation.class,IsEmptyFilterMixIn.class)
                     .put(Resource.class,IsEmptyFilterMixIn.class)
                     .put(ToscaDataDefinition.class,IsEmptyFilterMixIn.class)
-                    .build();
+                    .put(InterfaceOperationDataDefinition.class,IsEmptyFilterMixIn.class).build();
+
+
 
 }
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
index ff6d7d662f..69c4cec42b 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/ToscaExportHandler.java
@@ -45,7 +45,6 @@ import org.openecomp.sdc.be.model.ComponentParametersView;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.GroupInstance;
 import org.openecomp.sdc.be.model.InputDefinition;
-import org.openecomp.sdc.be.model.InterfaceDefinition;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.RelationshipInfo;
 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
@@ -56,9 +55,7 @@ import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
 import org.openecomp.sdc.be.model.category.CategoryDefinition;
 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
 import org.openecomp.sdc.be.model.jsontitan.utils.ModelConverter;
-import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
-import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
 import org.openecomp.sdc.be.tosca.model.ToscaGroupTemplate;
@@ -73,7 +70,6 @@ import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
 import org.openecomp.sdc.be.tosca.utils.ForwardingPathToscaUtil;
 import org.openecomp.sdc.be.tosca.utils.InputConverter;
 import org.openecomp.sdc.common.log.wrappers.Logger;
-import org.openecomp.sdc.exception.ResponseFormat;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.yaml.snakeyaml.DumperOptions;
 import org.yaml.snakeyaml.DumperOptions.FlowStyle;
@@ -116,12 +112,11 @@ public class ToscaExportHandler {
     private GroupExportParser groupExportParser;
     private PropertyConvertor propertyConvertor;
     private InputConverter inputConverter;
-    private InterfaceLifecycleOperation interfaceLifecycleOperation;
 
     @Autowired 
     public ToscaExportHandler(ApplicationDataTypeCache dataTypeCache, ToscaOperationFacade toscaOperationFacade,
                               CapabilityRequirementConverter capabilityRequirementConverter, PolicyExportParser policyExportParser,
-                              GroupExportParser groupExportParser, InputConverter inputConverter, InterfaceLifecycleOperation interfaceLifecycleOperation) {
+                              GroupExportParser groupExportParser, InputConverter inputConverter) {
             this.dataTypeCache = dataTypeCache;
             this.toscaOperationFacade = toscaOperationFacade;
             this.capabilityRequirementConverter = capabilityRequirementConverter;
@@ -129,7 +124,6 @@ public class ToscaExportHandler {
             this.groupExportParser = groupExportParser;
             this.propertyConvertor = PropertyConvertor.getInstance();
             this.inputConverter =  inputConverter;
-            this.interfaceLifecycleOperation = interfaceLifecycleOperation;
       }
 
 
@@ -559,15 +553,7 @@ public class ToscaExportHandler {
                                                                        boolean isAssociatedResourceComponent) {
         log.debug("start convert node type for {}", component.getUniqueId());
         ToscaNodeType toscaNodeType = createNodeType(component);
-
-        Either<Map<String, InterfaceDefinition>, StorageOperationStatus> lifecycleTypeEither = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes();
-        if(lifecycleTypeEither.isRight()){
-            log.debug("Failed to fetch all interface types :", lifecycleTypeEither.right().value());
-            return Either.right(ToscaError.GENERAL_ERROR);
-        }
-        List<String> allGlobalInterfaceTypes = lifecycleTypeEither.left().value().values().stream().map(interfaceDef -> interfaceDef.getType()).collect(Collectors.toList());
-        toscaNode.setInterface_types(addInterfaceTypeElement(component, allGlobalInterfaceTypes));
-
+        toscaNode.setInterface_types(addInterfaceTypeElement(component));
         Either<Map<String, DataTypeDefinition>, TitanOperationStatus> dataTypesEither = dataTypeCache.getAll();
         if (dataTypesEither.isRight()) {
             log.debug("Failed to fetch all data types :", dataTypesEither.right().value());
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java
index ef3023de6b..7afad74f64 100644
--- a/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java
+++ b/catalog-be/src/main/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtil.java
@@ -60,7 +60,7 @@ public class InterfacesOperationsToscaUtil {
      * @param component to work on
      * @return the added element
      */
-    public static Map<String, Object> addInterfaceTypeElement(Component component, List<String> allInterfaceTypes) {
+    public static Map<String, Object> addInterfaceTypeElement(Component component) {
         if (component instanceof Product) {
             return null;
         }
@@ -68,28 +68,24 @@ public class InterfacesOperationsToscaUtil {
         if (MapUtils.isEmpty(interfaces)) {
             return null;
         }
-
         Map<String, Object> toscaInterfaceTypes = new HashMap<>();
         for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
-            boolean isInterfaceTypeExistInGlobalType = allInterfaceTypes.stream().anyMatch(type -> type.equalsIgnoreCase(interfaceDefinition.getType()));
-            if(!isInterfaceTypeExistInGlobalType){
-                ToscaInterfaceNodeType toscaInterfaceType = new ToscaInterfaceNodeType();
-                toscaInterfaceType.setDerived_from(DERIVED_FROM_STANDARD_INTERFACE);
+            ToscaInterfaceNodeType toscaInterfaceType = new ToscaInterfaceNodeType();
+            toscaInterfaceType.setDerived_from(DERIVED_FROM_STANDARD_INTERFACE);
 
-                final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
-                Map<String, Object> toscaOperations = new HashMap<>();
+            final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
+            Map<String, Object> toscaOperations = new HashMap<>();
 
-                for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
-                    toscaOperations.put(operationEntry.getValue().getName(),
+            for (Map.Entry<String, OperationDataDefinition> operationEntry : operations.entrySet()) {
+                toscaOperations.put(operationEntry.getValue().getName(),
                         null); //currently not initializing any of the operations' fields as it is not needed
-                }
-                toscaInterfaceType.setOperations(toscaOperations);
-                Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
-                Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS_KEY);
-                interfacesAsMap.putAll(operationsMap);
-
-                toscaInterfaceTypes.put(interfaceDefinition.getType(), interfacesAsMap);
             }
+            toscaInterfaceType.setOperations(toscaOperations);
+            Map<String, Object> interfacesAsMap = getObjectAsMap(toscaInterfaceType);
+            Map<String, Object> operationsMap = (Map<String, Object>) interfacesAsMap.remove(OPERATIONS_KEY);
+            interfacesAsMap.putAll(operationsMap);
+
+            toscaInterfaceTypes.put(interfaceDefinition.getToscaResourceName(), interfacesAsMap);
         }
         return MapUtils.isNotEmpty(toscaInterfaceTypes) ? toscaInterfaceTypes : null;
     }
@@ -112,8 +108,8 @@ public class InterfacesOperationsToscaUtil {
         Map<String, Object> toscaInterfaceDefinitions = new HashMap<>();
         for (InterfaceDefinition interfaceDefinition : interfaces.values()) {
             ToscaInterfaceDefinition toscaInterfaceDefinition = new ToscaInterfaceDefinition();
-            final String interfaceType = interfaceDefinition.getType();
-            toscaInterfaceDefinition.setType(interfaceType);
+            final String toscaResourceName = interfaceDefinition.getToscaResourceName();
+            toscaInterfaceDefinition.setType(toscaResourceName);
             final Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
             Map<String, Object> toscaOperations = new HashMap<>();
 
@@ -137,7 +133,7 @@ public class InterfacesOperationsToscaUtil {
             Map<String, Object> operationsMap = (Map<String, Object>) interfaceDefAsMap.remove(OPERATIONS_KEY);
             handleDefaults(operationsMap);
             interfaceDefAsMap.putAll(operationsMap);
-            toscaInterfaceDefinitions.put(getLastPartOfName(interfaceType), interfaceDefAsMap);
+            toscaInterfaceDefinitions.put(getLastPartOfName(toscaResourceName), interfaceDefAsMap);
         }
         if (MapUtils.isNotEmpty(toscaInterfaceDefinitions)) {
             nodeType.setInterfaces(toscaInterfaceDefinitions);