Add collaboration feature

Issue-ID: SDC-767
Change-Id: I14fb4c1f54086ed03a56a7ff7fab9ecd40381795
Signed-off-by: talig <talig@amdocs.com>

121 files changed, 4582 insertions, 6254 deletions

diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java
index f9b6bfe8a9..492bfef019 100644
--- a/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java
@@ -20,14 +20,61 @@
 
 package org.openecomp.sdc.action.impl;
 
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
+import org.openecomp.core.util.UniqueValueUtil;
+import org.openecomp.core.utilities.CommonMethods;
+import org.openecomp.core.utilities.json.JsonUtil;
+import org.openecomp.sdc.action.ActionConstants;
+import org.openecomp.sdc.action.ActionManager;
+import org.openecomp.sdc.action.dao.ActionArtifactDao;
+import org.openecomp.sdc.action.dao.ActionArtifactDaoFactory;
+import org.openecomp.sdc.action.dao.ActionDao;
+import org.openecomp.sdc.action.dao.ActionDaoFactory;
+import org.openecomp.sdc.action.dao.types.ActionArtifactEntity;
+import org.openecomp.sdc.action.dao.types.ActionEntity;
+import org.openecomp.sdc.action.errors.ActionErrorConstants;
+import org.openecomp.sdc.action.errors.ActionException;
+import org.openecomp.sdc.action.logging.StatusCode;
+import org.openecomp.sdc.action.types.Action;
+import org.openecomp.sdc.action.types.ActionArtifact;
+import org.openecomp.sdc.action.types.ActionArtifactProtection;
+import org.openecomp.sdc.action.types.ActionStatus;
+import org.openecomp.sdc.action.types.ActionSubOperation;
+import org.openecomp.sdc.action.types.OpenEcompComponent;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder;
+import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+import org.slf4j.MDC;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
 import static org.openecomp.sdc.action.ActionConstants.ACTION_VERSIONABLE_TYPE;
 import static org.openecomp.sdc.action.ActionConstants.ARTIFACT_METADATA_ATTR_NAME;
 import static org.openecomp.sdc.action.ActionConstants.ARTIFACT_METADATA_ATTR_UUID;
 import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_CATEGORY;
-import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_OPEN_ECOMP_COMPONENT;
 import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_MODEL;
 import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_NAME;
 import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_NONE;
+import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_OPEN_ECOMP_COMPONENT;
 import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_VENDOR;
 import static org.openecomp.sdc.action.ActionConstants.SERVICE_INSTANCE_ID;
 import static org.openecomp.sdc.action.ActionConstants.STATUS;
@@ -68,49 +115,6 @@ import static org.openecomp.sdc.action.util.ActionUtil.actionLogPreProcessor;
 import static org.openecomp.sdc.action.util.ActionUtil.getCurrentTimeStampUtc;
 import static org.openecomp.sdc.versioning.dao.types.Version.VERSION_STRING_VIOLATION_MSG;
 
-import org.apache.commons.collections4.CollectionUtils;
-import org.apache.commons.lang.StringUtils;
-import org.openecomp.sdc.action.types.*;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
-import org.openecomp.core.util.UniqueValueUtil;
-import org.openecomp.core.utilities.CommonMethods;
-import org.openecomp.core.utilities.json.JsonUtil;
-import org.openecomp.sdc.action.ActionConstants;
-import org.openecomp.sdc.action.ActionManager;
-import org.openecomp.sdc.action.dao.ActionArtifactDao;
-import org.openecomp.sdc.action.dao.ActionArtifactDaoFactory;
-import org.openecomp.sdc.action.dao.ActionDao;
-import org.openecomp.sdc.action.dao.ActionDaoFactory;
-import org.openecomp.sdc.action.dao.types.ActionArtifactEntity;
-import org.openecomp.sdc.action.dao.types.ActionEntity;
-import org.openecomp.sdc.action.errors.ActionErrorConstants;
-import org.openecomp.sdc.action.errors.ActionException;
-import org.openecomp.sdc.action.logging.StatusCode;
-import org.openecomp.sdc.action.types.OpenEcompComponent;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.versioning.VersioningManager;
-import org.openecomp.sdc.versioning.VersioningManagerFactory;
-import org.openecomp.sdc.versioning.dao.VersionInfoDao;
-import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
-import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
-import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder;
-import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
-import org.slf4j.MDC;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
 /**
  * Manager Implementation for {@link ActionManager Action Library Operations} <br> Handles Business
  * layer validations and acts as an interface between the REST and DAO layers.
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java
index a8f7b692ab..582a4c7235 100644
--- a/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java
+++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/test/java/org/openecomp/sdc/action/ActionTest.java
@@ -20,57 +20,6 @@
 
 package org.openecomp.sdc.action;
 
-import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_NAME;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS_CODE;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER_CODE;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_NAME_INVALID;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_READ_ONLY_MSG;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_DELETE_ON_LOCKED_ENTITY_CODE;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_NOT_EXIST;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_ERROR;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_MSG;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_NOT_LOCKED_CODE;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_NOT_LOCKED_MSG;
-import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_ON_UNLOCKED_ENTITY;
-
-import org.openecomp.core.nosqldb.api.NoSqlDb;
-import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
-import org.openecomp.core.utilities.json.JsonUtil;
-import org.openecomp.sdc.action.dao.ActionDao;
-import org.openecomp.sdc.action.dao.ActionDaoFactory;
-import org.openecomp.sdc.action.dao.types.ActionEntity;
-import org.openecomp.sdc.action.errors.ActionErrorConstants;
-import org.openecomp.sdc.action.errors.ActionException;
-import org.openecomp.sdc.action.impl.ActionManagerImpl;
-import org.openecomp.sdc.action.types.Action;
-import org.openecomp.sdc.action.types.ActionArtifact;
-import org.openecomp.sdc.action.types.ActionArtifactProtection;
-import org.openecomp.sdc.action.types.ActionStatus;
-import org.openecomp.sdc.action.types.OpenEcompComponent;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.testng.Assert;
-import org.testng.annotations.BeforeTest;
-import org.testng.annotations.Test;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-
 @SuppressWarnings("Duplicates")
 public class ActionTest {
 
diff --git a/openecomp-be/backend/openecomp-sdc-activity-log-manager/pom.xml b/openecomp-be/backend/openecomp-sdc-activity-log-manager/pom.xml
index fc014cd3eb..4b0db49b7c 100644
--- a/openecomp-be/backend/openecomp-sdc-activity-log-manager/pom.xml
+++ b/openecomp-be/backend/openecomp-sdc-activity-log-manager/pom.xml
@@ -46,11 +46,6 @@
             <version>${project.version}</version>
             <scope>runtime</scope>
         </dependency>
-        <dependency>
-            <groupId>org.openecomp.sdc</groupId>
-            <artifactId>activity-log-rest-types</artifactId>
-            <version>${project.version}</version>
-        </dependency>
     </dependencies>
 
 
diff --git a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/ActivityLogManager.java b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/ActivityLogManager.java
index a40e1018d7..06de3e11b6 100644
--- a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/ActivityLogManager.java
+++ b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/ActivityLogManager.java
@@ -18,7 +18,7 @@
  * ============LICENSE_END=========================================================
  */
 
-package org.openecomp.sdc.activityLog;
+package org.openecomp.sdc.activitylog;
 
 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.versioning.dao.types.Version;
@@ -26,6 +26,8 @@ import org.openecomp.sdc.versioning.dao.types.Version;
 import java.util.Collection;
 
 public interface ActivityLogManager {
-    void addActionLog(ActivityLogEntity activityLogEntity, String user);
-    Collection<ActivityLogEntity> listActivityLogs(String itemId, Version versionId, String user);
+
+  void logActivity(ActivityLogEntity activityLogEntity);
+
+  Collection<ActivityLogEntity> listLoggedActivities(String itemId, Version versionId);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/ActivityLogManagerFactory.java b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/ActivityLogManagerFactory.java
index 9816b76486..93010f6560 100644
--- a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/ActivityLogManagerFactory.java
+++ b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/ActivityLogManagerFactory.java
@@ -17,11 +17,10 @@
  * limitations under the License.
  * ============LICENSE_END=========================================================
  */
-package org.openecomp.sdc.activityLog;
+package org.openecomp.sdc.activitylog;
 
 import org.openecomp.core.factory.api.AbstractComponentFactory;
 import org.openecomp.core.factory.api.AbstractFactory;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
 
 
 public abstract class ActivityLogManagerFactory extends AbstractComponentFactory<ActivityLogManager> {
diff --git a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/impl/ActivityLogManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/impl/ActivityLogManagerFactoryImpl.java
index 491192470d..5dc7f849fc 100644
--- a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/impl/ActivityLogManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/impl/ActivityLogManagerFactoryImpl.java
@@ -17,17 +17,18 @@
  * limitations under the License.
  * ============LICENSE_END=========================================================
  */
-package org.openecomp.sdc.activityLog.impl;
+package org.openecomp.sdc.activitylog.impl;
 
-import org.openecomp.sdc.activityLog.ActivityLogManager;
-import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
+import org.openecomp.sdc.activitylog.ActivityLogManager;
+import org.openecomp.sdc.activitylog.ActivityLogManagerFactory;
 import org.openecomp.sdc.activitylog.dao.ActivityLogDaoFactory;
 
 public class ActivityLogManagerFactoryImpl extends ActivityLogManagerFactory {
-    private static final ActivityLogManager INSTANCE = new ActivityLogManagerImpl(
-            ActivityLogDaoFactory.getInstance().createInterface()
-    );
+  private static final ActivityLogManager INSTANCE =
+      new ActivityLogManagerImpl(ActivityLogDaoFactory.getInstance().createInterface());
 
-    @Override
-    public ActivityLogManager createInterface() {return INSTANCE;}
+  @Override
+  public ActivityLogManager createInterface() {
+    return INSTANCE;
+  }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/impl/ActivityLogManagerImpl.java b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/impl/ActivityLogManagerImpl.java
index 324af2095a..711fd68a8e 100644
--- a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activityLog/impl/ActivityLogManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/java/org/openecomp/sdc/activitylog/impl/ActivityLogManagerImpl.java
@@ -18,36 +18,35 @@
  * ============LICENSE_END=========================================================
  */
 
-package org.openecomp.sdc.activityLog.impl;
+package org.openecomp.sdc.activitylog.impl;
 
 import org.openecomp.core.utilities.CommonMethods;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
+import org.openecomp.sdc.activitylog.ActivityLogManager;
 import org.openecomp.sdc.activitylog.dao.ActivityLogDao;
-import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
+import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.versioning.dao.types.Version;
 
 import java.util.Collection;
 
 public class ActivityLogManagerImpl implements ActivityLogManager {
-    private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
-    private ActivityLogDao activityLogDao;
+  private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
+  private ActivityLogDao activityLogDao;
 
-    public ActivityLogManagerImpl(ActivityLogDao activityLogDao) {
-        this.activityLogDao = activityLogDao;
-    }
+  public ActivityLogManagerImpl(ActivityLogDao activityLogDao) {
+    this.activityLogDao = activityLogDao;
+  }
 
-    @Override
-    public void addActionLog(ActivityLogEntity activityLogEntity, String user) {
-        mdcDataDebugMessage.debugEntryMessage("ITEM id", activityLogEntity.getItemId());
-        activityLogEntity.setId(CommonMethods.nextUuId());
-        activityLogDao.create(activityLogEntity);
-    }
+  @Override
+  public void logActivity(ActivityLogEntity activityLogEntity) {
+    mdcDataDebugMessage.debugEntryMessage("ITEM id", activityLogEntity.getItemId());
+    activityLogEntity.setId(CommonMethods.nextUuId());
+    activityLogDao.create(activityLogEntity);
+  }
 
-    @Override
-    public Collection<ActivityLogEntity> listActivityLogs(String itemId, Version version, String user) {
-        mdcDataDebugMessage.debugEntryMessage("ITEM id", itemId);
-        String versionId = version.getMinor() == 0 ? String.valueOf(version.getMajor()) : String.valueOf(version.getMajor()+1);
-        return activityLogDao.getActivityLogListForItem(itemId, versionId);
-    }
+  @Override
+  public Collection<ActivityLogEntity> listLoggedActivities(String itemId, Version version) {
+    mdcDataDebugMessage.debugEntryMessage("ITEM id", itemId);
+    return activityLogDao.list(new ActivityLogEntity(itemId, version));
+  }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/resources/factoryConfiguration.json b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/resources/factoryConfiguration.json
index b4e151d16b..e4d3dab0f0 100644
--- a/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/resources/factoryConfiguration.json
+++ b/openecomp-be/backend/openecomp-sdc-activity-log-manager/src/main/resources/factoryConfiguration.json
@@ -1,3 +1,3 @@
 {
-  "org.openecomp.sdc.activityLog.ActivityLogManagerFactory": "org.openecomp.sdc.activityLog.impl.ActivityLogManagerFactoryImpl"
+  "org.openecomp.sdc.activitylog.ActivityLogManagerFactory": "org.openecomp.sdc.activitylog.impl.ActivityLogManagerFactoryImpl"
 }
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-application-config-manager/src/test/java/org/openecomp/sdc/applicationconfig/ApplicationConfigManagerTest.java b/openecomp-be/backend/openecomp-sdc-application-config-manager/src/test/java/org/openecomp/sdc/applicationconfig/ApplicationConfigManagerTest.java
index 4217025da9..e58f455d11 100644
--- a/openecomp-be/backend/openecomp-sdc-application-config-manager/src/test/java/org/openecomp/sdc/applicationconfig/ApplicationConfigManagerTest.java
+++ b/openecomp-be/backend/openecomp-sdc-application-config-manager/src/test/java/org/openecomp/sdc/applicationconfig/ApplicationConfigManagerTest.java
@@ -20,14 +20,7 @@
 
 package org.openecomp.sdc.applicationconfig;
 
-import org.openecomp.core.utilities.applicationconfig.dao.type.ApplicationConfigEntity;
-import org.openecomp.core.utilities.applicationconfig.type.ConfigurationData;
 import org.openecomp.sdc.applicationconfig.impl.ApplicationConfigManagerImpl;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.testng.Assert;
-import org.testng.annotations.Test;
-
-import java.util.Collection;
 
 /**
  * Created by Talio on 8/9/2016.
diff --git a/openecomp-be/backend/openecomp-sdc-conflict-manager/pom.xml b/openecomp-be/backend/openecomp-sdc-conflict-manager/pom.xml
new file mode 100644
index 0000000000..4fa58b2028
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-conflict-manager/pom.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.openecomp.sdc</groupId>
+        <artifactId>backend</artifactId>
+        <version>1.2.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>openecomp-sdc-conflict-manager</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.openecomp.sdc.core</groupId>
+            <artifactId>openecomp-facade-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-conflict-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-conflict-core</artifactId>
+            <version>${project.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+    </dependencies>
+
+</project>
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/ConflictsManager.java b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/ConflictsManager.java
new file mode 100644
index 0000000000..d7c5c3f5ba
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/ConflictsManager.java
@@ -0,0 +1,20 @@
+package org.openecomp.sdc.conflicts;
+
+import org.openecomp.conflicts.types.Conflict;
+import org.openecomp.conflicts.types.ConflictResolution;
+import org.openecomp.conflicts.types.ItemVersionConflict;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+public interface ConflictsManager {
+
+  boolean isConflicted(String itemId, Version version);
+
+  ItemVersionConflict getConflict(String itemId, Version version);
+
+  void finalizeMerge(String itemId, Version version);
+
+  Conflict getConflict(String itemId, Version version, String conflictId);
+
+  void resolveConflict(String itemId, Version version, String conflictId,
+                       ConflictResolution resolution);
+}
diff --git a/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/ConflictsManagerFactory.java b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/ConflictsManagerFactory.java
new file mode 100644
index 0000000000..7a24cfd311
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/ConflictsManagerFactory.java
@@ -0,0 +1,30 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+package org.openecomp.sdc.conflicts;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+
+public abstract class ConflictsManagerFactory extends AbstractComponentFactory<ConflictsManager> {
+    public static ConflictsManagerFactory getInstance() {
+        return AbstractFactory.getInstance(ConflictsManagerFactory.class);
+    }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/impl/ConflictsManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/impl/ConflictsManagerFactoryImpl.java
new file mode 100644
index 0000000000..2d703c4a87
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/impl/ConflictsManagerFactoryImpl.java
@@ -0,0 +1,35 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+package org.openecomp.sdc.conflicts.impl;
+
+
+import org.openecomp.conflicts.dao.ConflictsDaoFactory;
+import org.openecomp.sdc.conflicts.ConflictsManager;
+import org.openecomp.sdc.conflicts.ConflictsManagerFactory;
+
+public class ConflictsManagerFactoryImpl extends ConflictsManagerFactory {
+  private static final ConflictsManager INSTANCE =
+      new ConflictsManagerImpl(ConflictsDaoFactory.getInstance().createInterface());
+
+  @Override
+  public ConflictsManager createInterface() {
+    return INSTANCE;
+  }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/impl/ConflictsManagerImpl.java b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/impl/ConflictsManagerImpl.java
new file mode 100644
index 0000000000..cb4c2dd993
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/java/org/openecomp/sdc/conflicts/impl/ConflictsManagerImpl.java
@@ -0,0 +1,112 @@
+package org.openecomp.sdc.conflicts.impl;
+
+import org.openecomp.conflicts.ItemMergeHandler;
+import org.openecomp.conflicts.ItemMergeHandlerFactory;
+import org.openecomp.conflicts.dao.ConflictsDao;
+import org.openecomp.conflicts.types.Conflict;
+import org.openecomp.conflicts.types.ConflictResolution;
+import org.openecomp.conflicts.types.ItemVersionConflict;
+import org.openecomp.conflicts.types.Resolution;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.conflicts.ConflictsManager;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+import java.util.Optional;
+
+public class ConflictsManagerImpl implements ConflictsManager {
+
+  private static final String ELEMENT_CONFLICT_NOT_EXIST_ERR_ID = "ELEMENT_CONFLICT_NOT_EXIST";
+  private static final String ELEMENT_CONFLICT_NOT_EXISTS_MSG =
+      "Item Id %s, version Id %s, element conflict with Id %s does not exists.";
+
+  private final ConflictsDao conflictsDao;
+
+  public ConflictsManagerImpl(ConflictsDao conflictsDao) {
+    this.conflictsDao = conflictsDao;
+  }
+
+  @Override
+  public boolean isConflicted(String itemId, Version version) {
+    Optional<ItemMergeHandler> itemMergeHandler =
+        ItemMergeHandlerFactory.getInstance().createInterface(itemId);
+
+    return conflictsDao.isConflicted(itemId, version) ||
+        (itemMergeHandler.isPresent() &&
+            itemMergeHandler.get().isConflicted(itemId, version));
+  }
+
+  @Override
+  public ItemVersionConflict getConflict(String itemId, Version version) {
+    ItemVersionConflict conflicts = conflictsDao.getConflict(itemId, version);
+
+    ItemMergeHandlerFactory.getInstance().createInterface(itemId)
+        .ifPresent(itemMergeHandler -> itemMergeHandler
+            .postListConflicts(itemId, version, conflicts));
+
+    return conflicts;
+  }
+
+  @Override
+  public void finalizeMerge(String itemId, Version version) {
+    ItemMergeHandlerFactory.getInstance().createInterface(itemId)
+        .ifPresent(mergeHandler -> mergeHandler.finalizeMerge(itemId, version));
+  }
+
+  @Override
+  public Conflict getConflict(String itemId, Version version, String conflictId) {
+    Optional<ItemMergeHandler> itemMergeHandler =
+        ItemMergeHandlerFactory.getInstance().createInterface(itemId);
+    if (itemMergeHandler.isPresent()) {
+      Optional<Conflict> conflict =
+          itemMergeHandler.get().getConflict(itemId, version, conflictId);
+      if (conflict.isPresent()) {
+        return conflict.get();
+      }
+    }
+
+    Conflict conflict = conflictsDao.getConflict(itemId, version, conflictId);
+
+    itemMergeHandler.ifPresent(mergeHandler ->
+        mergeHandler.postGetConflict(itemId, version, conflict));
+
+    if (conflict == null) {
+      throw getConflictNotExistException(itemId, version, conflictId);
+    }
+    return conflict;
+  }
+
+  @Override
+  public void resolveConflict(String itemId, Version version, String conflictId,
+                              ConflictResolution resolution) {
+    if (Resolution.OTHER.equals(resolution.getResolution())) {
+      throw new UnsupportedOperationException(
+          "Resolution other than 'THEIRS' or 'YOURS' is not supported.");
+    }
+
+    Optional<ItemMergeHandler> itemMergeHandler =
+        ItemMergeHandlerFactory.getInstance().createInterface(itemId);
+    if (!itemMergeHandler.isPresent() ||
+        !itemMergeHandler.get()
+            .resolveConflict(itemId, version, conflictId, resolution)) {
+
+      getConflict(itemId, version, conflictId); // validate that the conflict exist
+      itemMergeHandler.ifPresent(mergeHandler ->
+          mergeHandler.preResolveConflict(itemId, version, conflictId, resolution));
+
+      conflictsDao.resolveConflict(itemId, version, conflictId, resolution);
+    }
+  }
+
+  private CoreException getConflictNotExistException(String itemId, Version version,
+                                                     String conflictId) {
+    return new CoreException(new ErrorCode.ErrorCodeBuilder()
+        .withCategory(ErrorCategory.APPLICATION)
+        .withId(ELEMENT_CONFLICT_NOT_EXIST_ERR_ID)
+        .withMessage(
+            String.format(ELEMENT_CONFLICT_NOT_EXISTS_MSG, itemId, version.getId(), conflictId))
+        .build());
+  }
+
+}
diff --git a/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/resources/factoryConfiguration.json b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/resources/factoryConfiguration.json
new file mode 100644
index 0000000000..58e57ab2fa
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-conflict-manager/src/main/resources/factoryConfiguration.json
@@ -0,0 +1,3 @@
+{
+  "org.openecomp.sdc.conflicts.ConflictsManagerFactory": "org.openecomp.sdc.conflicts.impl.ConflictsManagerFactoryImpl"
+}
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-healthcheck-manager/pom.xml b/openecomp-be/backend/openecomp-sdc-healthcheck-manager/pom.xml
index 0fd84b8a0f..35777c2469 100644
--- a/openecomp-be/backend/openecomp-sdc-healthcheck-manager/pom.xml
+++ b/openecomp-be/backend/openecomp-sdc-healthcheck-manager/pom.xml
@@ -35,11 +35,6 @@
             <version>${project.version}</version>
         </dependency>
         <dependency>
-            <groupId>org.openecomp.sdc</groupId>
-            <artifactId>activity-log-rest-types</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
             <groupId>org.openecomp.sdc.core</groupId>
             <artifactId>openecomp-zusammen-core</artifactId>
             <version>${project.version}</version>
diff --git a/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerFactoryImpl.java
index 1da515fac0..e5d85a2641 100644
--- a/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerFactoryImpl.java
@@ -19,7 +19,8 @@
  */
 package org.openecomp.sdc.health.impl;
 
-import org.openecomp.sdc.health.*;
+import org.openecomp.sdc.health.HealthCheckManager;
+import org.openecomp.sdc.health.HealthCheckManagerFactory;
 
 public class HealthCheckManagerFactoryImpl extends HealthCheckManagerFactory {
     private static final HealthCheckManager INSTANCE ;
diff --git a/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerImpl.java b/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerImpl.java
index 2ee15811af..f96b3a3b4e 100644
--- a/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-healthcheck-manager/src/main/java/org/openecomp/sdc/health/impl/HealthCheckManagerImpl.java
@@ -26,14 +26,14 @@ import com.amdocs.zusammen.datatypes.SessionContext;
 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
 import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory;
 import org.openecomp.core.zusammen.api.ZusammenUtil;
+import org.openecomp.sdc.health.HealthCheckDao;
+import org.openecomp.sdc.health.HealthCheckDaoFactory;
 import org.openecomp.sdc.health.HealthCheckManager;
 import org.openecomp.sdc.health.data.HealthCheckStatus;
 import org.openecomp.sdc.health.data.MonitoredModules;
 import org.openecomp.sdc.logging.api.Logger;
 import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
-import org.openecomp.sdc.health.HealthCheckDao;
-import org.openecomp.sdc.health.HealthCheckDaoFactory;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/pom.xml b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/pom.xml
new file mode 100644
index 0000000000..3212205620
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/pom.xml
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+
+    <parent>
+        <groupId>org.openecomp.sdc</groupId>
+        <artifactId>backend</artifactId>
+        <version>1.2.0-SNAPSHOT</version>
+
+    </parent>
+
+    <artifactId>openecomp-sdc-item-permissions-manager</artifactId>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>org.openecomp.sdc.core</groupId>
+            <artifactId>openecomp-session-lib</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.openecomp.sdc.core</groupId>
+            <artifactId>openecomp-facade-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-item-permissions-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-item-permissions-impl</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-item-permissions-core</artifactId>
+            <version>${project.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-sdc-versioning-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-sdc-notification-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <version>RELEASE</version>
+        </dependency>
+</dependencies>
+
+</project>
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/ItemPermissionsManager.java b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/ItemPermissionsManager.java
new file mode 100644
index 0000000000..74fc3d3c46
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/ItemPermissionsManager.java
@@ -0,0 +1,23 @@
+package org.openecomp.sdc.itempermissions;
+
+import org.openecomp.sdc.itempermissions.type.ItemPermissionsEntity;
+
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * Created by ayalaben on 6/18/2017.
+ */
+public interface ItemPermissionsManager {
+
+  Collection<ItemPermissionsEntity> listItemPermissions(String itemId);
+
+  void updateItemPermissions(String itemId, String permission, Set<String> addedUsersIds,
+                             Set<String> removedUsersIds);
+
+  boolean isAllowed(String itemId,String userId,String action);
+
+  String getUserItemPermiission(String itemId, String userId);
+
+
+}
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/ItemPermissionsManagerFactory.java b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/ItemPermissionsManagerFactory.java
new file mode 100644
index 0000000000..b983314b31
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/ItemPermissionsManagerFactory.java
@@ -0,0 +1,15 @@
+package org.openecomp.sdc.itempermissions;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+/**
+ * Created by ayalaben on 6/18/2017.
+ */
+public abstract class ItemPermissionsManagerFactory extends
+    AbstractComponentFactory<ItemPermissionsManager> {
+
+  public static ItemPermissionsManagerFactory getInstance() {
+    return AbstractFactory.getInstance(ItemPermissionsManagerFactory.class);
+  }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerFactoryImpl.java
new file mode 100644
index 0000000000..2255ad5fc3
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerFactoryImpl.java
@@ -0,0 +1,25 @@
+package org.openecomp.sdc.itempermissions.dao.impl;
+
+import org.openecomp.sdc.itempermissions.ItemPermissionsManager;
+import org.openecomp.sdc.itempermissions.ItemPermissionsManagerFactory;
+import org.openecomp.sdc.itempermissions.PermissionsServicesFactory;
+import org.openecomp.sdc.notification.factories.NotificationPropagationManagerFactory;
+import org.openecomp.sdc.notification.factories.SubscriptionServiceFactory;
+import org.openecomp.sdc.versioning.ItemManagerFactory;
+
+/**
+ * Created by ayalaben on 6/18/2017
+ */
+public class ItemPermissionsManagerFactoryImpl extends ItemPermissionsManagerFactory {
+
+    private static final ItemPermissionsManager INSTANCE =
+        new ItemPermissionsManagerImpl(PermissionsServicesFactory.getInstance().createInterface(),
+            ItemManagerFactory.getInstance().createInterface(),
+            NotificationPropagationManagerFactory.getInstance().createInterface(),
+            SubscriptionServiceFactory.getInstance().createInterface());
+
+    @Override
+    public ItemPermissionsManager createInterface() {
+        return INSTANCE;
+    }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerImpl.java b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerImpl.java
new file mode 100644
index 0000000000..b9fcfcdbed
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerImpl.java
@@ -0,0 +1,159 @@
+package org.openecomp.sdc.itempermissions.dao.impl;
+
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.common.errors.Messages;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+import org.openecomp.sdc.itempermissions.ItemPermissionsManager;
+import org.openecomp.sdc.itempermissions.PermissionsServices;
+import org.openecomp.sdc.itempermissions.type.ItemPermissionsEntity;
+import org.openecomp.sdc.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
+import org.openecomp.sdc.notification.dtos.Event;
+import org.openecomp.sdc.notification.services.NotificationPropagationManager;
+import org.openecomp.sdc.notification.services.SubscriptionService;
+import org.openecomp.sdc.versioning.ItemManager;
+import org.openecomp.sdc.versioning.types.Item;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.ITEM_ID_PROP;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.ITEM_NAME_PROP;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_CHANGED;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_GRANTED;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_ITEM;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_USER;
+
+/**
+ * Created by ayalaben on 6/18/2017.
+ */
+public class ItemPermissionsManagerImpl implements ItemPermissionsManager {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(ItemPermissionsManagerImpl.class);
+  private static final String CHANGE_PERMISSIONS = "Change_Item_Permissions";
+
+  private PermissionsServices permissionsServices;
+  private ItemManager itemManager;
+  private NotificationPropagationManager notifier;
+  private SubscriptionService subscriptionService;
+
+  public ItemPermissionsManagerImpl(PermissionsServices permissionsServices,
+                                    ItemManager itemManager,
+                                    NotificationPropagationManager notificationPropagationManager,
+                                    SubscriptionService subscriptionService) {
+    this.permissionsServices = permissionsServices;
+    this.itemManager = itemManager;
+    this.notifier = notificationPropagationManager;
+    this.subscriptionService = subscriptionService;
+  }
+
+  @Override
+  public Collection<ItemPermissionsEntity> listItemPermissions(String itemId) {
+
+    return permissionsServices.listItemPermissions(itemId);
+  }
+
+  @Override
+  public void updateItemPermissions(String itemId, String permission, Set<String> addedUsersIds,
+                                    Set<String> removedUsersIds) {
+
+    String currentUser =
+        SessionContextProviderFactory.getInstance().createInterface().get().getUser().getUserId();
+
+    if (!permissionsServices.isAllowed(itemId, currentUser, CHANGE_PERMISSIONS)) {
+      throw new CoreException(new ErrorCode.ErrorCodeBuilder()
+          .withMessage(Messages.PERMISSIONS_ERROR.getErrorMessage())
+          .withId(Messages.PERMISSIONS_ERROR.getErrorMessage())
+          .withCategory(ErrorCategory.SECURITY).build());
+    }
+
+    permissionsServices
+        .updateItemPermissions(itemId, permission, addedUsersIds, removedUsersIds);
+    sendNotifications(itemId, permission, addedUsersIds, removedUsersIds, currentUser);
+  }
+
+  private void sendNotifications(String itemId, String permission, Set<String> addedUsersIds,
+                                   Set<String> removedUsersIds, String userName) {
+
+    Item item = itemManager.get(itemId);
+    addedUsersIds.forEach(affectedUser -> {
+      notifyUser(userName, true, item.getName(), itemId, affectedUser, permission);
+      subscriptionService.subscribe(affectedUser, itemId);
+    });
+    removedUsersIds.forEach(affectedUser -> {
+      notifyUser(userName, false, item.getName(), itemId, affectedUser, permission);
+      subscriptionService.unsubscribe(affectedUser, itemId);
+    });
+
+  }
+
+  private void notifyUser(String userName, boolean granted, String itemName, String itemId,
+                          String affectedUser, String permission) {
+    Map<String, Object> details = new HashMap<>();
+    details.put(PERMISSION_ITEM, permission);
+    details.put(ITEM_ID_PROP, itemId);
+    details.put(ITEM_NAME_PROP, itemName);
+    details.put(PERMISSION_GRANTED, granted);
+    details.put(PERMISSION_USER, userName);
+    PermissionEvent permissionEvent = new PermissionEvent(PERMISSION_CHANGED, affectedUser,
+        details, affectedUser);
+
+    try {
+      notifier.directNotification(permissionEvent, affectedUser);
+    } catch (Exception e) {
+      LOGGER.error("Failed to send notification on permission changed for user '" +
+          affectedUser + "'");
+    }
+
+  }
+
+  @Override
+  public boolean isAllowed(String itemId, String userId, String action) {
+    return permissionsServices.isAllowed(itemId, userId, action);
+  }
+
+  @Override
+  public String getUserItemPermiission(String itemId, String userId) {
+    return permissionsServices.getUserItemPermiission(itemId, userId);
+  }
+
+  private class PermissionEvent implements Event {
+
+    private String eventType;
+    private String originatorId;
+    private Map<String, Object> attributes;
+    private String entityId;
+
+    private PermissionEvent(String eventType, String originatorId,
+                            Map<String, Object> attributes, String entityId) {
+      this.eventType = eventType;
+      this.originatorId = originatorId;
+      this.attributes = attributes;
+      this.entityId = entityId;
+    }
+
+    @Override
+    public String getEventType() {
+      return eventType;
+    }
+
+    @Override
+    public String getOriginatorId() {
+      return originatorId;
+    }
+
+    @Override
+    public Map<String, Object> getAttributes() {
+      return attributes;
+    }
+
+    @Override
+    public String getEntityId() {
+      return entityId;
+    }
+  }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/resources/factoryConfiguration.json b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/resources/factoryConfiguration.json
new file mode 100644
index 0000000000..a98f9c07f9
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/main/resources/factoryConfiguration.json
@@ -0,0 +1,3 @@
+{
+  "org.openecomp.sdc.itempermissions.ItemPermissionsManagerFactory": "org.openecomp.sdc.itempermissions.dao.impl.ItemPermissionsManagerFactoryImpl"
+}
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerImplTest.java
new file mode 100644
index 0000000000..e4618246d8
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/ItemPermissionsManagerImplTest.java
@@ -0,0 +1,86 @@
+package org.openecomp.sdc.itempermissions.dao.impl;
+
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+import org.openecomp.sdc.itempermissions.PermissionsServices;
+import org.openecomp.sdc.notification.services.NotificationPropagationManager;
+import org.openecomp.sdc.notification.services.SubscriptionService;
+import org.openecomp.sdc.versioning.ItemManager;
+import org.openecomp.sdc.versioning.types.Item;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Created by ayalaben on 7/6/2017
+ */
+public class ItemPermissionsManagerImplTest {
+
+  private static final String ITEM1_ID = "1";
+  private static final String PERMISSION = "Contributor";
+  private static final String ACTION = "Change_Item_Permissions";
+  private static final String USER = "user";
+  private static final String AFFECTED_USER1 = "affected_user1";
+  private static final String AFFECTED_USER2 = "affected_user2";
+  private static final String AFFECTED_USER3 = "affected_user3";
+
+  @Mock
+  private PermissionsServices permissionsServicesMock;
+  @Mock
+  private ItemManager itemManagerMock;
+  @Mock
+  private SubscriptionService subscriptionServiceMock;
+  @Mock
+  private NotificationPropagationManager notifierMock;
+  @InjectMocks
+  private ItemPermissionsManagerImpl permissionsManager;
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    SessionContextProviderFactory.getInstance().createInterface().create(USER);
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Permissions " +
+      "Error. The user does not have permission to perform this action.")
+  public void testUpdateItemPermissionsWhenNotAllowed() {
+    doReturn(false).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
+
+    permissionsManager
+        .updateItemPermissions(ITEM1_ID, PERMISSION, Collections.singleton(AFFECTED_USER1),
+            new HashSet<>());
+  }
+
+  @Test
+  public void testUpdateItemPermissions() {
+    doReturn(true).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
+    Item item = new Item();
+    item.setName("Item 1 Name");
+    doReturn(item).when(itemManagerMock).get(ITEM1_ID);
+
+    Set<String> addedUsersIds =
+        Stream.of(AFFECTED_USER1, AFFECTED_USER2).collect(Collectors.toSet());
+    Set<String> removedUsersIds = Collections.singleton(AFFECTED_USER3);
+    permissionsManager
+        .updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
+
+    verify(permissionsServicesMock)
+        .updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
+    verify(subscriptionServiceMock).subscribe(AFFECTED_USER1, ITEM1_ID);
+    verify(subscriptionServiceMock).subscribe(AFFECTED_USER2, ITEM1_ID);
+    verify(subscriptionServiceMock).unsubscribe(AFFECTED_USER3, ITEM1_ID);
+
+    // TODO: 12/18/2017 verify notification
+  }
+}
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/resources/logback.xml b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/resources/logback.xml
new file mode 100644
index 0000000000..c1932e31e8
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/resources/logback.xml
@@ -0,0 +1,15 @@
+<configuration>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <!-- encoders are assigned the type
+             ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="warn">
+        <appender-ref ref="STDOUT" />
+    </root>
+
+</configuration>
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/impl/UploadValidationManagerImpl.java b/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/impl/UploadValidationManagerImpl.java
index 1d1ce4f03c..924235d799 100644
--- a/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/impl/UploadValidationManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/impl/UploadValidationManagerImpl.java
@@ -25,10 +25,10 @@ import org.apache.commons.collections4.MapUtils;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.core.utilities.file.FileUtils;
 import org.openecomp.core.validation.api.ValidationManager;
-import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.common.utils.SdcCommon;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
 import org.openecomp.sdc.datatypes.error.ErrorMessage;
diff --git a/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/util/ValidationManagerUtil.java b/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/util/ValidationManagerUtil.java
index 53b05eb953..7a78f09f69 100644
--- a/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/util/ValidationManagerUtil.java
+++ b/openecomp-be/backend/openecomp-sdc-validation-manager/src/main/java/org/openecomp/sdc/validation/util/ValidationManagerUtil.java
@@ -23,8 +23,8 @@ package org.openecomp.sdc.validation.util;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.core.utilities.file.FileUtils;
 import org.openecomp.core.validation.api.ValidationManager;
-import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.core.validation.factory.ValidationManagerFactory;
+import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.common.utils.SdcCommon;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
 import org.openecomp.sdc.datatypes.error.ErrorMessage;
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
index a76b9b865d..9184afe823 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
@@ -28,8 +28,6 @@ import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
 import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
 import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
-import org.openecomp.sdc.vendorlicense.errors.LimitErrorBuilder;
-import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
 import org.openecomp.sdc.versioning.dao.types.Version;
 
 import java.util.Collection;
@@ -37,88 +35,71 @@ import java.util.Set;
 
 public interface VendorLicenseManager {
 
-  void checkout(String vendorLicenseModelId, String user);
+  void validate(String vendorLicenseModelId, Version version);
 
-  void undoCheckout(String vendorLicenseModelId, String user);
+  VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity licenseModel);
 
-  void checkin(String vendorLicenseModelId, String user);
+  void updateVendorLicenseModel(VendorLicenseModelEntity licenseModel);
 
-  void submit(String vendorLicenseModelId, String user);
+  VendorLicenseModelEntity getVendorLicenseModel(String vlmId, Version version);
 
-  Collection<VersionedVendorLicenseModel> listVendorLicenseModels(String versionFilter,
-                                                                  String user);
+  void deleteVendorLicenseModel(String vlmId, Version version);
 
-  VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity licenseModel,
-                                                    String user);
 
-  void updateVendorLicenseModel(VendorLicenseModelEntity licenseModel, String user);
+  Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version);
 
-  VersionedVendorLicenseModel getVendorLicenseModel(String vlmId, Version version, String user);
-
-  void deleteVendorLicenseModel(String vlmId, String user);
-
-
-  Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version,
-                                                           String user);
-
-  LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement,
-                                                String user);
+  LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement);
 
   void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement,
-                              Set<String> addedFeatureGroupIds, Set<String> removedFeatureGroupIds,
-                              String user);
+                              Set<String> addedFeatureGroupIds, Set<String> removedFeatureGroupIds);
 
   LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version,
-                                                 String licenseAgreementId, String user);
+                                                 String licenseAgreementId);
 
-  void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId, String user);
+  void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId);
 
 
-  Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version, String user);
+  Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version);
 
-  FeatureGroupEntity createFeatureGroup(FeatureGroupEntity fg, String user);
+  FeatureGroupEntity createFeatureGroup(FeatureGroupEntity fg);
 
   void updateFeatureGroup(FeatureGroupEntity featureGroup,
                           Set<String> addedLicenseKeyGroups, Set<String> removedLicenseKeyGroups,
-                          Set<String> addedEntitlementPools, Set<String> removedEntitlementPools,
-                          String user);
-
-  FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup, String user);
+                          Set<String> addedEntitlementPools, Set<String> removedEntitlementPools);
 
-  void deleteFeatureGroup(FeatureGroupEntity featureGroup, String user);
+  FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup);
 
+  void deleteFeatureGroup(FeatureGroupEntity featureGroup);
 
-  Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version,
-                                                         String user);
 
-  EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool, String user);
+  Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version);
 
-  void updateEntitlementPool(EntitlementPoolEntity entitlementPool, String user);
+  EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool);
 
-  EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool, String user);
+  void updateEntitlementPool(EntitlementPoolEntity entitlementPool);
 
-  void deleteEntitlementPool(EntitlementPoolEntity entitlementPool, String user);
+  EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool);
 
+  void deleteEntitlementPool(EntitlementPoolEntity entitlementPool);
 
-  Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version,
-                                                         String user);
 
-  LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user);
+  Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version);
 
-  void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user);
+  LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
 
-  LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user);
+  void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
 
-  void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user);
+  LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
 
-  LimitEntity createLimit(LimitEntity limitEntity, String user);
+  void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup);
 
-  Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId, String user);
+  LimitEntity createLimit(LimitEntity limitEntity);
 
-  void deleteLimit(LimitEntity limitEntity, String user);
+  Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId);
 
-  void updateLimit(LimitEntity limitEntity, String user);
+  void deleteLimit(LimitEntity limitEntity);
 
-  LimitEntity getLimit(LimitEntity entitlementPool, String user);
+  void updateLimit(LimitEntity limitEntity);
 
+  LimitEntity getLimit(LimitEntity entitlementPool);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java
index 152ddd0e13..472473fdb0 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerFactoryImpl.java
@@ -1,6 +1,5 @@
 package org.openecomp.sdc.vendorlicense.impl;
 
-import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
 import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
 import org.openecomp.sdc.vendorlicense.VendorLicenseManagerFactory;
 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDaoFactory;
@@ -10,22 +9,19 @@ import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDaoFactory;
 import org.openecomp.sdc.vendorlicense.dao.LimitDaoFactory;
 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
-import org.openecomp.sdc.versioning.VersioningManagerFactory;
 
 /**
  * Created by ayalaben on 8/3/2017
  */
-public class VendorLicenseManagerFactoryImpl  extends VendorLicenseManagerFactory {
+public class VendorLicenseManagerFactoryImpl extends VendorLicenseManagerFactory {
   private static final VendorLicenseManager INSTANCE =
       new VendorLicenseManagerImpl(
-          VersioningManagerFactory.getInstance().createInterface(),
           VendorLicenseFacadeFactory.getInstance().createInterface(),
           VendorLicenseModelDaoFactory.getInstance().createInterface(),
           LicenseAgreementDaoFactory.getInstance().createInterface(),
           FeatureGroupDaoFactory.getInstance().createInterface(),
           EntitlementPoolDaoFactory.getInstance().createInterface(),
           LicenseKeyGroupDaoFactory.getInstance().createInterface(),
-          ActivityLogManagerFactory.getInstance().createInterface(),
           LimitDaoFactory.getInstance().createInterface());
 
   @Override
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
index e07a13c2e8..2489b5a89b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
@@ -20,16 +20,10 @@
 
 package org.openecomp.sdc.vendorlicense.impl;
 
-import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE;
-
 import org.openecomp.core.util.UniqueValueUtil;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
-import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
 import org.openecomp.sdc.logging.types.LoggerConstants;
@@ -57,26 +51,16 @@ import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
 import org.openecomp.sdc.vendorlicense.errors.InvalidDateErrorBuilder;
 import org.openecomp.sdc.vendorlicense.errors.LimitErrorBuilder;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
-import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
-import org.openecomp.sdc.versioning.VersioningManager;
 import org.openecomp.sdc.versioning.VersioningUtil;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.dao.types.VersionStatus;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
-import org.openecomp.sdcrests.activitylog.types.ActivityType;
 
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
 import java.util.Collection;
-import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 
 public class VendorLicenseManagerImpl implements VendorLicenseManager {
-  private VersioningManager versioningManager;
   private VendorLicenseFacade vendorLicenseFacade;
   private VendorLicenseModelDao vendorLicenseModelDao;
   private LicenseAgreementDao licenseAgreementDao;
@@ -84,278 +68,134 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
   private EntitlementPoolDao entitlementPoolDao;
   private LicenseKeyGroupDao licenseKeyGroupDao;
   private LimitDao limitDao;
-  private ActivityLogManager activityLogManager;
 
   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
-  private static final Logger logger =
-          LoggerFactory.getLogger(VendorLicenseManagerImpl.class);
 
-  public VendorLicenseManagerImpl(VersioningManager versioningManager,
-                                  VendorLicenseFacade vendorLicenseFacade,
+  public VendorLicenseManagerImpl(VendorLicenseFacade vendorLicenseFacade,
                                   VendorLicenseModelDao vendorLicenseModelDao,
                                   LicenseAgreementDao licenseAgreementDao,
                                   FeatureGroupDao featureGroupDao,
                                   EntitlementPoolDao entitlementPoolDao,
                                   LicenseKeyGroupDao licenseKeyGroupDao,
-                                  ActivityLogManager activityLogManager,
                                   LimitDao limitDao) {
-    this.versioningManager = versioningManager;
     this.vendorLicenseFacade = vendorLicenseFacade;
     this.vendorLicenseModelDao = vendorLicenseModelDao;
     this.licenseAgreementDao = licenseAgreementDao;
     this.featureGroupDao = featureGroupDao;
     this.entitlementPoolDao = entitlementPoolDao;
     this.licenseKeyGroupDao = licenseKeyGroupDao;
-    this.activityLogManager = activityLogManager;
     this.limitDao = limitDao;
   }
 
 
-  private static void sortVlmListByModificationTimeDescOrder(
-          List<VersionedVendorLicenseModel> vendorLicenseModels) {
-    vendorLicenseModels.sort((o1, o2) -> o2.getVendorLicenseModel().getWritetimeMicroSeconds()
-            .compareTo(o1.getVendorLicenseModel().getWritetimeMicroSeconds()));
-  }
-
   @Override
-  public void checkout(String vendorLicenseModelId, String user) {
-
+  public void validate(String vendorLicenseModelId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
 
-    Version newVersion = versioningManager
-            .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user);
-
-    ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId, String.valueOf(newVersion.getMajor()+1),
-            ActivityType.CHECKOUT.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-
-    newVersion.setStatus(VersionStatus.Locked);
-    vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion);
+    vendorLicenseFacade.validate(vendorLicenseModelId, version);
 
     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
   }
 
   @Override
-  public void undoCheckout(String vendorLicenseModelId, String user) {
-
-    mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
-
-    Version newVersion = versioningManager
-            .undoCheckout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user);
-
-    ActivityLogEntity activityLogEntity =
-        new ActivityLogEntity(vendorLicenseModelId, String.valueOf(newVersion.getMajor() + 1),
-            ActivityType.UNDO_CHECKOUT.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-
-    vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion);
-
-    mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
-  }
-
-  @Override
-  public void checkin(String vendorLicenseModelId, String user) {
-
-    mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
-
-    Version newVersion = vendorLicenseFacade.checkin(vendorLicenseModelId, user);
-
-    ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId,
-            String.valueOf(newVersion.getMajor()+1), ActivityType.CHECKIN.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-
-    mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
-  }
-
-  @Override
-  public void submit(String vendorLicenseModelId, String user) {
-
-    mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelId);
-
-    Version newVersion = vendorLicenseFacade.submit(vendorLicenseModelId, user);
-
-    ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelId, String.valueOf(newVersion.getMajor()),
-            ActivityType.SUBMIT.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-
-    mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelId);
-  }
-
-  @Override
-  public Collection<VersionedVendorLicenseModel> listVendorLicenseModels(String versionFilter,
-                                                                         String user) {
+  public VendorLicenseModelEntity createVendorLicenseModel(
+      VendorLicenseModelEntity vendorLicenseModelEntity) {
     mdcDataDebugMessage.debugEntryMessage(null);
 
-    Map<String, VersionInfo> idToVersionsInfo = versioningManager
-            .listEntitiesVersionInfo(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, user,
-                    VersionableEntityAction.Read);
-
-    List<VersionedVendorLicenseModel> vendorLicenseModels = new ArrayList<>();
-    for (Map.Entry<String, VersionInfo> entry : idToVersionsInfo.entrySet()) {
-      VersionInfo versionInfo = entry.getValue();
-      if (versionFilter != null && versionFilter.equals(VersionStatus.Final.name())) {
-        if (versionInfo.getLatestFinalVersion() == null) {
-          continue;
-        }
-        versionInfo.setActiveVersion(versionInfo.getLatestFinalVersion());
-        versionInfo.setStatus(VersionStatus.Final);
-        versionInfo.setLockingUser(null);
-      }
-
-      Version version = versionInfo.getActiveVersion();
-      if (user.equals(versionInfo.getLockingUser())) {
-        version.setStatus(VersionStatus.Locked);
-      }
-
-      try {
-        VendorLicenseModelEntity vlm =
-                vendorLicenseModelDao.get(new VendorLicenseModelEntity(entry.getKey(), version));
-        if (vlm != null) {
-          VersionedVendorLicenseModel versionedVlm = new VersionedVendorLicenseModel();
-          versionedVlm.setVendorLicenseModel(vlm);
-          versionedVlm.setVersionInfo(versionInfo);
-          vendorLicenseModels.add(versionedVlm);
-        }
-      }catch(RuntimeException rte){
-        logger.error("Error trying to retrieve vlm["+entry.getKey()+"] version["+version.toString
-                ()+"] " +
-                "message:"+rte
-                .getMessage());
-      }
-    }
-
-    sortVlmListByModificationTimeDescOrder(vendorLicenseModels);
-
+    vendorLicenseModelDao.create(vendorLicenseModelEntity);
     mdcDataDebugMessage.debugExitMessage(null);
-    return vendorLicenseModels;
-  }
-
-  @Override
-  public VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity, String user) {
-
-    VendorLicenseModelEntity vendorLicenseModelCreated = vendorLicenseFacade.createVendorLicenseModel(vendorLicenseModelEntity, user);
-
-    ActivityLogEntity activityLogEntity = new ActivityLogEntity(vendorLicenseModelCreated.getId(),
-            String.valueOf(vendorLicenseModelCreated.getVersion().getMajor()+1),
-            ActivityType.CREATE_NEW.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
 
-    return vendorLicenseModelCreated;
+    return vendorLicenseModelEntity;
   }
 
   @Override
-  public void updateVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity,
-                                       String user) {
+  public void updateVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", vendorLicenseModelEntity.getId());
 
-    Version version = resloveVersion(vendorLicenseModelEntity.getId(),null,
-            getVersionInfo(vendorLicenseModelEntity.getId(), VersionableEntityAction.Write, user),
-            user);
-    vendorLicenseModelEntity.setVersion(version);
-
     String existingVendorName = vendorLicenseModelDao.get(vendorLicenseModelEntity).getVendorName();
 
     updateUniqueName(VendorLicenseConstants.UniqueValues.VENDOR_NAME, existingVendorName,
-            vendorLicenseModelEntity.getVendorName());
+        vendorLicenseModelEntity.getVendorName());
     vendorLicenseModelDao.update(vendorLicenseModelEntity);
 
-    vendorLicenseFacade
-            .updateVlmLastModificationTime(vendorLicenseModelEntity.getId(), version);
-
     mdcDataDebugMessage.debugExitMessage("VLM id", vendorLicenseModelEntity.getId());
   }
 
   @Override
-  public VersionedVendorLicenseModel getVendorLicenseModel(String vlmId, Version version,
-                                                           String user) {
-    return vendorLicenseFacade.getVendorLicenseModel(vlmId, version, user);
+  public VendorLicenseModelEntity getVendorLicenseModel(String vlmId, Version version) {
+    return vendorLicenseFacade.getVendorLicenseModel(vlmId, version);
   }
 
   @Override
-  public void deleteVendorLicenseModel(String vlmId, String user) {
+  public void deleteVendorLicenseModel(String vlmId, Version version) {
     MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-            LoggerTragetServiceName.DELETE_ENTITY, ErrorLevel.ERROR.name(),
-            LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.UNSUPPORTED_OPERATION);
+        LoggerTragetServiceName.DELETE_ENTITY, ErrorLevel.ERROR.name(),
+        LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.UNSUPPORTED_OPERATION);
     throw new UnsupportedOperationException(VendorLicenseConstants.UNSUPPORTED_OPERATION_ERROR);
   }
 
   @Override
-  public Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version,
-                                                                  String user) {
+  public Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
-    LicenseAgreementEntity licenseAgreementEntity =  createLicenseAgreementForList(vlmId, version,
-            user);
-//    return licenseAgreementDao.list(new LicenseAgreementEntity(vlmId, VersioningUtil
-//        .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user), user),
-//        null));
-    return licenseAgreementDao.list(licenseAgreementEntity);
+    return licenseAgreementDao.list(new LicenseAgreementEntity(vlmId, version, null));
   }
 
   @Override
-  public LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement,
-                                                       String user) {
+  public LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement) {
     mdcDataDebugMessage
-            .debugEntryMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
+        .debugEntryMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
     mdcDataDebugMessage
-            .debugExitMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
-    return vendorLicenseFacade.createLicenseAgreement(licenseAgreement, user);
+        .debugExitMessage("VLM id", licenseAgreement.getVendorLicenseModelId());
+    return vendorLicenseFacade.createLicenseAgreement(licenseAgreement);
   }
 
   @Override
   public void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement,
                                      Set<String> addedFeatureGroupIds,
-                                     Set<String> removedFeatureGroupIds, String user) {
+                                     Set<String> removedFeatureGroupIds) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", licenseAgreement
-            .getVendorLicenseModelId(), licenseAgreement.getId());
+        .getVendorLicenseModelId(), licenseAgreement.getId());
 
-    Version version = VersioningUtil.resolveVersion(licenseAgreement.getVersion(),
-            getVersionInfo(licenseAgreement.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    licenseAgreement.setVersion(version);
     LicenseAgreementEntity retrieved = licenseAgreementDao.get(licenseAgreement);
     VersioningUtil
-            .validateEntityExistence(retrieved, licenseAgreement, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, licenseAgreement, VendorLicenseModelEntity.ENTITY_TYPE);
     VersioningUtil.validateContainedEntitiesExistence(new FeatureGroupEntity().getEntityType(),
-            removedFeatureGroupIds, retrieved, retrieved.getFeatureGroupIds());
+        removedFeatureGroupIds, retrieved, retrieved.getFeatureGroupIds());
     VersioningUtil.validateEntitiesExistence(addedFeatureGroupIds,
-            new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(), version, null),
-            featureGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
+        new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
+            licenseAgreement.getVersion(),
+            null),
+        featureGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
 
     updateUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
-            retrieved.getName(), licenseAgreement.getName(), licenseAgreement.getVendorLicenseModelId(),
-            licenseAgreement.getVersion().toString());
+        retrieved.getName(), licenseAgreement.getName(), licenseAgreement.getVendorLicenseModelId(),
+        licenseAgreement.getVersion().getId());
     licenseAgreementDao.updateColumnsAndDeltaFeatureGroupIds(licenseAgreement, addedFeatureGroupIds,
-            removedFeatureGroupIds);
+        removedFeatureGroupIds);
 
     addFeatureGroupsToLicenseAgreementRef(addedFeatureGroupIds, licenseAgreement);
     removeFeatureGroupsToLicenseAgreementRef(removedFeatureGroupIds, licenseAgreement);
 
-    vendorLicenseFacade
-            .updateVlmLastModificationTime(licenseAgreement.getVendorLicenseModelId(), version);
-
     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", licenseAgreement
-            .getVendorLicenseModelId(), licenseAgreement.getId());
+        .getVendorLicenseModelId(), licenseAgreement.getId());
   }
 
   @Override
   public LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version,
-                                                        String licenseAgreementId, String user) {
+                                                        String licenseAgreementId) {
 
     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", vlmId, licenseAgreementId);
     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", vlmId, licenseAgreementId);
-    return vendorLicenseFacade.getLicenseAgreementModel(vlmId, version, licenseAgreementId, user);
+    return vendorLicenseFacade.getLicenseAgreementModel(vlmId, version, licenseAgreementId);
   }
 
   @Override
-  public void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId,
-                                     String user) {
+  public void deleteLicenseAgreement(String vlmId, Version version, String licenseAgreementId) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, LA id", vlmId, licenseAgreementId);
 
-    version = VersioningUtil
-            .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Write, user), user);
     LicenseAgreementEntity input =
-            new LicenseAgreementEntity(vlmId, version, licenseAgreementId);
+        new LicenseAgreementEntity(vlmId, version, licenseAgreementId);
     LicenseAgreementEntity retrieved = licenseAgreementDao.get(input);
     VersioningUtil.validateEntityExistence(retrieved, input, VendorLicenseModelEntity.ENTITY_TYPE);
 
@@ -364,29 +204,25 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     licenseAgreementDao.delete(retrieved);
 
     deleteUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME,
-            retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
-            retrieved.getName());
-
-    vendorLicenseFacade
-            .updateVlmLastModificationTime(input.getVendorLicenseModelId(), input.getVersion());
+        retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
+        retrieved.getName());
 
     mdcDataDebugMessage.debugExitMessage("VLM id, LA id", vlmId, licenseAgreementId);
   }
 
   @Override
-  public Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version,
-                                                          String user) {
+  public Collection<FeatureGroupEntity> listFeatureGroups(String vlmId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
-    return vendorLicenseFacade.listFeatureGroups(vlmId, version, user);
+    return vendorLicenseFacade.listFeatureGroups(vlmId, version);
   }
 
   @Override
-  public FeatureGroupEntity createFeatureGroup(FeatureGroupEntity featureGroup, String user) {
+  public FeatureGroupEntity createFeatureGroup(FeatureGroupEntity featureGroup) {
     mdcDataDebugMessage
-            .debugEntryMessage("VLM id", featureGroup.getVendorLicenseModelId());
+        .debugEntryMessage("VLM id", featureGroup.getVendorLicenseModelId());
     mdcDataDebugMessage.debugExitMessage("VLM id", featureGroup.getId());
-    return vendorLicenseFacade.createFeatureGroup(featureGroup, user);
+    return vendorLicenseFacade.createFeatureGroup(featureGroup);
   }
 
   @Override
@@ -394,35 +230,31 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
                                  Set<String> addedLicenseKeyGroups,
                                  Set<String> removedLicenseKeyGroups,
                                  Set<String> addedEntitlementPools,
-                                 Set<String> removedEntitlementPools,
-                                 String user) {
+                                 Set<String> removedEntitlementPools) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id", featureGroup
-            .getVendorLicenseModelId(), featureGroup.getId());
-
-    Version version = VersioningUtil.resolveVersion(featureGroup.getVersion(),
-            getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write, user),
-            user);
-    featureGroup.setVersion(version);
+        .getVendorLicenseModelId(), featureGroup.getId());
 
     FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
     VersioningUtil
-            .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 
     VersioningUtil.validateContainedEntitiesExistence(new LicenseKeyGroupEntity().getEntityType(),
-            removedLicenseKeyGroups, retrieved, retrieved.getLicenseKeyGroupIds());
+        removedLicenseKeyGroups, retrieved, retrieved.getLicenseKeyGroupIds());
     VersioningUtil.validateContainedEntitiesExistence(new EntitlementPoolEntity().getEntityType(),
-            removedEntitlementPools, retrieved, retrieved.getEntitlementPoolIds());
+        removedEntitlementPools, retrieved, retrieved.getEntitlementPoolIds());
 
     VersioningUtil.validateEntitiesExistence(addedLicenseKeyGroups,
-            new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), version, null),
-            licenseKeyGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
+        new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(),
+            null),
+        licenseKeyGroupDao, VendorLicenseModelEntity.ENTITY_TYPE);
     VersioningUtil.validateEntitiesExistence(addedEntitlementPools,
-            new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), version, null),
-            entitlementPoolDao, VendorLicenseModelEntity.ENTITY_TYPE);
+        new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), featureGroup.getVersion(),
+            null),
+        entitlementPoolDao, VendorLicenseModelEntity.ENTITY_TYPE);
 
     updateUniqueName(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
-            retrieved.getName(), featureGroup.getName(), featureGroup.getVendorLicenseModelId(),
-            featureGroup.getVersion().toString());
+        retrieved.getName(), featureGroup.getName(), featureGroup.getVendorLicenseModelId(),
+        featureGroup.getVersion().getId());
 
     addLicenseKeyGroupsToFeatureGroupsRef(addedLicenseKeyGroups, featureGroup);
     removeLicenseKeyGroupsToFeatureGroupsRef(removedLicenseKeyGroups, featureGroup);
@@ -430,413 +262,364 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     removeEntitlementPoolsToFeatureGroupsRef(removedEntitlementPools, featureGroup);
 
     featureGroupDao.updateFeatureGroup(featureGroup, addedEntitlementPools, removedEntitlementPools,
-            addedLicenseKeyGroups, removedLicenseKeyGroups);
-
-    vendorLicenseFacade
-            .updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(), version);
+        addedLicenseKeyGroups, removedLicenseKeyGroups);
 
     mdcDataDebugMessage.debugExitMessage("VLM id, FG id", featureGroup
-            .getVendorLicenseModelId(), featureGroup.getId());
+        .getVendorLicenseModelId(), featureGroup.getId());
   }
 
   @Override
-  public FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup, String user) {
+  public FeatureGroupModel getFeatureGroupModel(FeatureGroupEntity featureGroup) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id",
-            featureGroup.getVendorLicenseModelId(), featureGroup.getId());
+        featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 
     mdcDataDebugMessage.debugExitMessage("VLM id, FG id",
-            featureGroup.getVendorLicenseModelId(), featureGroup.getId());
-    return vendorLicenseFacade.getFeatureGroupModel(featureGroup, user);
+        featureGroup.getVendorLicenseModelId(), featureGroup.getId());
+    return vendorLicenseFacade.getFeatureGroupModel(featureGroup);
   }
 
   @Override
-  public void deleteFeatureGroup(FeatureGroupEntity featureGroup, String user) {
+  public void deleteFeatureGroup(FeatureGroupEntity featureGroup) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, FG id",
-            featureGroup.getVendorLicenseModelId(), featureGroup.getId());
+        featureGroup.getVendorLicenseModelId(), featureGroup.getId());
 
-    Version version = VersioningUtil.resolveVersion(featureGroup.getVersion(),
-            getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    featureGroup.setVersion(version);
     FeatureGroupEntity retrieved = featureGroupDao.get(featureGroup);
     VersioningUtil
-            .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 
     removeLicenseKeyGroupsToFeatureGroupsRef(retrieved.getLicenseKeyGroupIds(), featureGroup);
     removeEntitlementPoolsToFeatureGroupsRef(retrieved.getEntitlementPoolIds(), featureGroup);
 
     for (String licenceAgreementId : retrieved.getReferencingLicenseAgreements()) {
       licenseAgreementDao.removeFeatureGroup(
-              new LicenseAgreementEntity(featureGroup.getVendorLicenseModelId(), version,
-                      licenceAgreementId), featureGroup.getId());
+          new LicenseAgreementEntity(featureGroup.getVendorLicenseModelId(),
+              featureGroup.getVersion(),
+              licenceAgreementId), featureGroup.getId());
     }
 
     featureGroupDao.delete(featureGroup);
 
     deleteUniqueName(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME,
-            retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
-            retrieved.getName());
-
-    vendorLicenseFacade.updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(),
-            featureGroup.getVersion());
+        retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
+        retrieved.getName());
 
     mdcDataDebugMessage
-            .debugExitMessage("VLM id, FG id",
-                    featureGroup.getVendorLicenseModelId(), featureGroup.getId());
+        .debugExitMessage("VLM id, FG id",
+            featureGroup.getVendorLicenseModelId(), featureGroup.getId());
   }
 
   @Override
-  public Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version,
-                                                                String user) {
+  public Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
-    return vendorLicenseFacade.listEntitlementPools(vlmId, version, user);
+    return vendorLicenseFacade.listEntitlementPools(vlmId, version);
   }
 
   @Override
-  public EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool,
-                                                     String user) {
+  public EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool) {
     mdcDataDebugMessage
-            .debugEntryMessage("VLM id", entitlementPool.getVendorLicenseModelId());
+        .debugEntryMessage("VLM id", entitlementPool.getVendorLicenseModelId());
     mdcDataDebugMessage
-            .debugExitMessage("VLM id", entitlementPool.getVendorLicenseModelId());
+        .debugExitMessage("VLM id", entitlementPool.getVendorLicenseModelId());
 
     entitlementPool.setStartDate(entitlementPool.getStartDate() != null ? (entitlementPool
-            .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate()+"T00:00:00Z"
-            : null) : null);
+        .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate() + "T00:00:00Z"
+        : null) : null);
     entitlementPool.setExpiryDate(entitlementPool.getExpiryDate() != null ? (entitlementPool
-            .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate()+"T23:59:59Z"
-            : null) : null);
+        .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate() + "T23:59:59Z"
+        : null) : null);
 
     validateCreateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(),
-            entitlementPool.getVendorLicenseModelId());
-    return vendorLicenseFacade.createEntitlementPool(entitlementPool, user);
+        entitlementPool.getVendorLicenseModelId());
+    return vendorLicenseFacade.createEntitlementPool(entitlementPool);
   }
 
-  private void validateCreateDate(String startDate, String expiryDate, String vendorLicenseModelId){
+  private void validateCreateDate(String startDate, String expiryDate,
+                                  String vendorLicenseModelId) {
     mdcDataDebugMessage.debugEntryMessage("Start date and end date", startDate
-            +"   "+expiryDate);
+        + "   " + expiryDate);
 
     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
 
-    if(startDate != null && expiryDate != null) {
+    if (startDate != null && expiryDate != null) {
       if (LocalDate.parse(startDate, formatter).atStartOfDay().isBefore
-              (LocalDate.now().atStartOfDay()) || LocalDate.parse(expiryDate, formatter).atStartOfDay()
-              .isEqual(LocalDate.parse(startDate, formatter).atStartOfDay()) || LocalDate
-              .parse(expiryDate, formatter).isBefore(LocalDate.parse(startDate, formatter))) {
+          (LocalDate.now().atStartOfDay()) || LocalDate.parse(expiryDate, formatter).atStartOfDay()
+          .isEqual(LocalDate.parse(startDate, formatter).atStartOfDay()) || LocalDate
+          .parse(expiryDate, formatter).isBefore(LocalDate.parse(startDate, formatter))) {
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-                LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
-                LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+            LoggerTragetServiceName.VALIDATE_DATE_RANGE, ErrorLevel.ERROR.name(),
+            LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
         throw new CoreException(
-                new InvalidDateErrorBuilder(vendorLicenseModelId)
-                        .build());
+            new InvalidDateErrorBuilder(vendorLicenseModelId)
+                .build());
       }
     }
 
-    if(startDate != null && expiryDate == null) {
+    if (startDate != null && expiryDate == null) {
       if (LocalDate.parse(startDate, formatter).atStartOfDay().isBefore
-              (LocalDate.now().atStartOfDay())) {
+          (LocalDate.now().atStartOfDay())) {
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-                LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
-                LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+            LoggerTragetServiceName.VALIDATE_DATE_RANGE, ErrorLevel.ERROR.name(),
+            LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
         throw new CoreException(
-                new InvalidDateErrorBuilder(vendorLicenseModelId)
-                        .build());
+            new InvalidDateErrorBuilder(vendorLicenseModelId)
+                .build());
       }
     }
 
-    if(startDate == null && expiryDate != null) {
+    if (startDate == null && expiryDate != null) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
-              LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+          LoggerTragetServiceName.VALIDATE_DATE_RANGE, ErrorLevel.ERROR.name(),
+          LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
       throw new CoreException(
-              new InvalidDateErrorBuilder(vendorLicenseModelId)
-                      .build());
+          new InvalidDateErrorBuilder(vendorLicenseModelId)
+              .build());
 
     }
 
-    mdcDataDebugMessage.debugExitMessage(null,null);
+    mdcDataDebugMessage.debugExitMessage(null);
   }
 
-  private void validateUpdateDate(String startDate, String expiryDate, String vendorLicenseModelId){
+  private void validateUpdateDate(String startDate, String expiryDate,
+                                  String vendorLicenseModelId) {
     mdcDataDebugMessage.debugEntryMessage("Start date and end date", startDate
-            +"   "+ expiryDate);
+        + "   " + expiryDate);
 
     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
 
-    if(startDate != null && expiryDate != null) {
+    if (startDate != null && expiryDate != null) {
       if (LocalDate.parse(expiryDate, formatter).atStartOfDay()
-              .isEqual(LocalDate.parse(startDate, formatter).atStartOfDay()) ||
-              LocalDate.parse(expiryDate, formatter).isBefore(LocalDate.parse(startDate, formatter))) {
+          .isEqual(LocalDate.parse(startDate, formatter).atStartOfDay()) ||
+          LocalDate.parse(expiryDate, formatter).isBefore(LocalDate.parse(startDate, formatter))) {
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-                LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
-                LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+            LoggerTragetServiceName.VALIDATE_DATE_RANGE, ErrorLevel.ERROR.name(),
+            LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
         throw new CoreException(
-                new InvalidDateErrorBuilder(vendorLicenseModelId)
-                        .build());
+            new InvalidDateErrorBuilder(vendorLicenseModelId)
+                .build());
       }
     }
 
-    if(startDate == null && expiryDate != null) {
+    if (startDate == null && expiryDate != null) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
-              LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+          LoggerTragetServiceName.VALIDATE_DATE_RANGE, ErrorLevel.ERROR.name(),
+          LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
       throw new CoreException(
-              new InvalidDateErrorBuilder(vendorLicenseModelId)
-                      .build());
+          new InvalidDateErrorBuilder(vendorLicenseModelId)
+              .build());
 
     }
 
-    mdcDataDebugMessage.debugExitMessage(null,null);
+    mdcDataDebugMessage.debugExitMessage(null);
   }
 
   @Override
-  public void updateEntitlementPool(EntitlementPoolEntity entitlementPool, String user) {
+  public void updateEntitlementPool(EntitlementPoolEntity entitlementPool) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
-            .getVendorLicenseModelId(), entitlementPool.getId());
+        .getVendorLicenseModelId(), entitlementPool.getId());
 
     entitlementPool.setStartDate(entitlementPool.getStartDate() != null ? (entitlementPool
-            .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate()+"T00:00:00Z"
-            : null) : null);
+        .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate() + "T00:00:00Z"
+        : null) : null);
     entitlementPool.setExpiryDate(entitlementPool.getExpiryDate() != null ? (entitlementPool
-            .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate()+"T23:59:59Z"
-            : null) : null);
+        .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate() + "T23:59:59Z"
+        : null) : null);
 
     validateUpdateDate(entitlementPool.getStartDate(), entitlementPool.getExpiryDate(),
-            entitlementPool.getVendorLicenseModelId());
-    Version version = VersioningUtil.resolveVersion(entitlementPool.getVersion(),
-            getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    vendorLicenseFacade
-            .updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(), version);
-    vendorLicenseFacade.updateEntitlementPool(entitlementPool, user);
+        entitlementPool.getVendorLicenseModelId());
+    vendorLicenseFacade.updateEntitlementPool(entitlementPool);
 
     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
-            .getVendorLicenseModelId(), entitlementPool.getId());
+        .getVendorLicenseModelId(), entitlementPool.getId());
   }
 
   @Override
-  public EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool,
-                                                  String user) {
+  public EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
-            .getVendorLicenseModelId(), entitlementPool.getId());
-
-    entitlementPool.setVersion(VersioningUtil.resolveVersion(entitlementPool.getVersion(),
-            getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Read,
-                    user), user));
+        .getVendorLicenseModelId(), entitlementPool.getId());
 
     EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
     VersioningUtil
-            .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
 
     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
     DateTimeFormatter targetFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-    if(retrieved.getStartDate() != null){
-      retrieved.setStartDate(LocalDate.parse(retrieved.getStartDate(),formatter).format
-              (targetFormatter));
+    if (retrieved.getStartDate() != null) {
+      retrieved.setStartDate(LocalDate.parse(retrieved.getStartDate(), formatter).format
+          (targetFormatter));
     }
 
-    if(retrieved.getExpiryDate() != null){
-      retrieved.setExpiryDate(LocalDate.parse(retrieved.getExpiryDate(),formatter).format
-              (targetFormatter));
+    if (retrieved.getExpiryDate() != null) {
+      retrieved.setExpiryDate(LocalDate.parse(retrieved.getExpiryDate(), formatter).format
+          (targetFormatter));
     }
 
     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
-            .getVendorLicenseModelId(), entitlementPool.getId());
+        .getVendorLicenseModelId(), entitlementPool.getId());
     return retrieved;
   }
 
   @Override
-  public void deleteEntitlementPool(EntitlementPoolEntity entitlementPool, String user) {
+  public void deleteEntitlementPool(EntitlementPoolEntity entitlementPool) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
-            .getVendorLicenseModelId(), entitlementPool.getId());
-
-    Version version = VersioningUtil.resolveVersion(entitlementPool.getVersion(),
-            getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    entitlementPool.setVersion(version);
+        .getVendorLicenseModelId(), entitlementPool.getId());
 
     EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool);
     VersioningUtil
-            .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
 
     for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
       featureGroupDao.removeEntitlementPool(
-              new FeatureGroupEntity(entitlementPool.getVendorLicenseModelId(), version,
-                      referencingFeatureGroupId), entitlementPool.getId());
+          new FeatureGroupEntity(entitlementPool.getVendorLicenseModelId(),
+              entitlementPool.getVersion(),
+              referencingFeatureGroupId), entitlementPool.getId());
     }
 
-    deleteChildLimits(entitlementPool.getVendorLicenseModelId(), entitlementPool.getVersion(), entitlementPool.getId(), user);
+    deleteChildLimits(entitlementPool.getVendorLicenseModelId(), entitlementPool.getVersion(),
+        entitlementPool.getId());
 
     entitlementPoolDao.delete(entitlementPool);
 
     deleteUniqueName(VendorLicenseConstants.UniqueValues.ENTITLEMENT_POOL_NAME,
-            retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
-            retrieved.getName());
-
-    vendorLicenseFacade.updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(),
-            entitlementPool.getVersion());
+        retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
+        retrieved.getName());
 
     mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
-            .getVendorLicenseModelId(), entitlementPool.getId());
+        .getVendorLicenseModelId(), entitlementPool.getId());
   }
 
-  protected void deleteChildLimits(String vlmId, Version version, String epLkgId, String user) {
+  protected void deleteChildLimits(String vlmId, Version version, String epLkgId) {
     Optional<Collection<LimitEntity>> limitEntities = Optional.ofNullable(
-            listLimits(vlmId, version, epLkgId, user));
-    limitEntities.ifPresent(entities->
-            entities.forEach(entity->
-                    deleteLimit(entity, user)));
+        listLimits(vlmId, version, epLkgId));
+    limitEntities.ifPresent(entities -> entities.forEach(this::deleteLimit));
   }
 
   @Override
-  public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version,
-                                                                String user) {
+  public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId);
     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId);
-    return vendorLicenseFacade.listLicenseKeyGroups(vlmId, version, user);
+    return vendorLicenseFacade.listLicenseKeyGroups(vlmId, version);
   }
 
   @Override
-  public LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup,
-                                                     String user) {
+  public LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
     mdcDataDebugMessage
-            .debugEntryMessage("VLM id", licenseKeyGroup.getVendorLicenseModelId());
+        .debugEntryMessage("VLM id", licenseKeyGroup.getVendorLicenseModelId());
 
     mdcDataDebugMessage.debugExitMessage("VLM id", licenseKeyGroup
-            .getVendorLicenseModelId());
+        .getVendorLicenseModelId());
 
     licenseKeyGroup.setStartDate(licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup
-            .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate()+"T00:00:00Z"
-            : null) : null);
+        .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate() + "T00:00:00Z"
+        : null) : null);
     licenseKeyGroup.setExpiryDate(licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup
-            .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate()+"T23:59:59Z"
-            : null) : null);
+        .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate() + "T23:59:59Z"
+        : null) : null);
 
     validateCreateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(),
-            licenseKeyGroup.getVendorLicenseModelId());
-    return vendorLicenseFacade.createLicenseKeyGroup(licenseKeyGroup, user);
+        licenseKeyGroup.getVendorLicenseModelId());
+    return vendorLicenseFacade.createLicenseKeyGroup(licenseKeyGroup);
   }
 
   @Override
-  public void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) {
+  public void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
-            .getVendorLicenseModelId(), licenseKeyGroup.getId());
+        .getVendorLicenseModelId(), licenseKeyGroup.getId());
 
     licenseKeyGroup.setStartDate(licenseKeyGroup.getStartDate() != null ? (licenseKeyGroup
-            .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate()+"T00:00:00Z"
-            : null) : null);
+        .getStartDate().trim().length() != 0 ? licenseKeyGroup.getStartDate() + "T00:00:00Z"
+        : null) : null);
     licenseKeyGroup.setExpiryDate(licenseKeyGroup.getExpiryDate() != null ? (licenseKeyGroup
-            .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate()+"T23:59:59Z"
-            : null) : null);
+        .getExpiryDate().trim().length() != 0 ? licenseKeyGroup.getExpiryDate() + "T23:59:59Z"
+        : null) : null);
 
     validateUpdateDate(licenseKeyGroup.getStartDate(), licenseKeyGroup.getExpiryDate(),
-            licenseKeyGroup.getVendorLicenseModelId());
-
-    Version version = VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
-            getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    vendorLicenseFacade
-            .updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(), version);
-
-    vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroup, user);
+        licenseKeyGroup.getVendorLicenseModelId());
+    vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroup);
 
     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
-            .getVendorLicenseModelId(), licenseKeyGroup.getId());
+        .getVendorLicenseModelId(), licenseKeyGroup.getId());
   }
 
   @Override
-  public LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup,
-                                                  String user) {
+  public LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
-            .getVendorLicenseModelId(), licenseKeyGroup.getId());
-
-    licenseKeyGroup.setVersion(VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
-            getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Read,
-                    user), user));
+        .getVendorLicenseModelId(), licenseKeyGroup.getId());
 
     LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
     VersioningUtil
-            .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 
     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
-            .getVendorLicenseModelId(), licenseKeyGroup.getId());
+        .getVendorLicenseModelId(), licenseKeyGroup.getId());
     return retrieved;
   }
 
   @Override
-  public void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) {
+  public void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, LKG id", licenseKeyGroup
-            .getVendorLicenseModelId(), licenseKeyGroup.getId());
-
-    Version version = VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(),
-            getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    licenseKeyGroup.setVersion(version);
+        .getVendorLicenseModelId(), licenseKeyGroup.getId());
 
     LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup);
     VersioningUtil
-            .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE);
 
     for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) {
       featureGroupDao.removeLicenseKeyGroup(
-              new FeatureGroupEntity(licenseKeyGroup.getVendorLicenseModelId(), version,
-                      referencingFeatureGroupId), licenseKeyGroup.getId());
+          new FeatureGroupEntity(licenseKeyGroup.getVendorLicenseModelId(),
+              licenseKeyGroup.getVersion(),
+              referencingFeatureGroupId), licenseKeyGroup.getId());
     }
 
-    deleteChildLimits(licenseKeyGroup.getVendorLicenseModelId(), licenseKeyGroup.getVersion(), licenseKeyGroup.getId(), user);
+    deleteChildLimits(licenseKeyGroup.getVendorLicenseModelId(), licenseKeyGroup.getVersion(),
+        licenseKeyGroup.getId());
 
     licenseKeyGroupDao.delete(licenseKeyGroup);
 
     deleteUniqueName(VendorLicenseConstants.UniqueValues.LICENSE_KEY_GROUP_NAME,
-            retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
-            retrieved.getName());
-
-    vendorLicenseFacade.updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(),
-            licenseKeyGroup.getVersion());
+        retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(),
+        retrieved.getName());
 
     mdcDataDebugMessage.debugExitMessage("VLM id, LKG id", licenseKeyGroup
-            .getVendorLicenseModelId(), licenseKeyGroup.getId());
+        .getVendorLicenseModelId(), licenseKeyGroup.getId());
   }
 
   @Override
-  public LimitEntity createLimit(LimitEntity limit, String user) {
+  public LimitEntity createLimit(LimitEntity limit) {
     mdcDataDebugMessage
-            .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
-                    .getEpLkgId());
+        .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+            .getEpLkgId());
     mdcDataDebugMessage
-            .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
-                    .getEpLkgId());
-    validateLimit(limit, user);
-    LimitEntity createdLimit = vendorLicenseFacade.createLimit(limit, user);
-    updateParentForLimit(limit,user);
+        .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+            .getEpLkgId());
+    validateLimit(limit);
+    LimitEntity createdLimit = vendorLicenseFacade.createLimit(limit);
+    updateParentForLimit(limit);
     return createdLimit;
   }
 
-  private void validateLimit(LimitEntity limit, String user) {
-    Version version = VersioningUtil.resolveVersion(limit.getVersion(),
-            getVersionInfo(limit.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    Collection<LimitEntity> limitList = listLimits(limit.getVendorLicenseModelId(),version
-            ,limit.getEpLkgId(), user);
+  private void validateLimit(LimitEntity limit) {
+    Collection<LimitEntity> limitList =
+        listLimits(limit.getVendorLicenseModelId(), limit.getVersion()
+            , limit.getEpLkgId());
 
-    if (!isLimitNameUnique(limitList,limit.getName(), limit.getType(), limit.getId())) {
+    if (!isLimitNameUnique(limitList, limit.getName(), limit.getType(), limit.getId())) {
       final ErrorCode duplicateLimitNameErrorBuilder =
-              LimitErrorBuilder.getDuplicateNameErrorbuilder(limit.getName(), limit.getType().name());
+          LimitErrorBuilder.getDuplicateNameErrorbuilder(limit.getName(), limit.getType().name());
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerServiceName.Create_LIMIT.toString(), ErrorLevel.ERROR.name(),
-              LoggerErrorCode.DATA_ERROR.getErrorCode(),
-              duplicateLimitNameErrorBuilder.message());
+          LoggerServiceName.Create_LIMIT.toString(), ErrorLevel.ERROR.name(),
+          LoggerErrorCode.DATA_ERROR.getErrorCode(),
+          duplicateLimitNameErrorBuilder.message());
       throw new CoreException(duplicateLimitNameErrorBuilder);
     }
   }
 
   private boolean isLimitNameUnique(Collection<LimitEntity> limitList, String name, LimitType
-          type, String id) {
+      type, String id) {
     for (LimitEntity limit : limitList) {
-      if(limit.getName().equalsIgnoreCase(name) &&
-              limit.getType().name().equalsIgnoreCase(type.name())) {
-        if(id != null && limit.getId().equals(id)){
+      if (limit.getName().equalsIgnoreCase(name) &&
+          limit.getType().name().equalsIgnoreCase(type.name())) {
+        if (id != null && limit.getId().equals(id)) {
           continue;
         }
         return false;
@@ -846,54 +629,45 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
   }
 
   @Override
-  public Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId,
-                                            String user) {
+  public Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
     mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
-    return vendorLicenseFacade.listLimits(vlmId, version, epLkgId, user);
+    return vendorLicenseFacade.listLimits(vlmId, version, epLkgId);
   }
 
   @Override
-  public void deleteLimit(LimitEntity limitEntity, String user) {
+  public void deleteLimit(LimitEntity limitEntity) {
     mdcDataDebugMessage.debugEntryMessage("VLM id, EP id, Limit Id", limitEntity
-            .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
-
-    Version version = VersioningUtil.resolveVersion(limitEntity.getVersion(),
-            getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Write,
-                    user), user);
-    limitEntity.setVersion(version);
+        .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
 
-    if ( !isLimitPresent(limitEntity)) {
+    if (!isLimitPresent(limitEntity)) {
       VersioningUtil
-              .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+          .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
     }
     LimitEntity retrieved = limitDao.get(limitEntity);
     VersioningUtil
-            .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 
     limitDao.delete(limitEntity);
 
-    vendorLicenseFacade.updateVlmLastModificationTime(limitEntity.getVendorLicenseModelId(),
-            limitEntity.getVersion());
-
-    updateParentForLimit(limitEntity,user);
+    updateParentForLimit(limitEntity);
 
     mdcDataDebugMessage.debugExitMessage("VLM id, EP id, Limit Id", limitEntity
-            .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
+        .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
   }
 
   @Override
-  public void updateLimit(LimitEntity limit, String user) {
+  public void updateLimit(LimitEntity limit) {
     mdcDataDebugMessage
-            .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
-                    .getEpLkgId());
-    getLimit(limit,user);
-    validateLimit(limit, user);
-    vendorLicenseFacade.updateLimit(limit, user);
-    updateParentForLimit(limit,user);
+        .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+            .getEpLkgId());
+    getLimit(limit);
+    validateLimit(limit);
+    vendorLicenseFacade.updateLimit(limit);
+    updateParentForLimit(limit);
     mdcDataDebugMessage
-            .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
-                    .getEpLkgId());
+        .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+            .getEpLkgId());
   }
 
   private boolean isLimitPresent(LimitEntity limit) {
@@ -901,52 +675,46 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
   }
 
   @Override
-  public LimitEntity getLimit(LimitEntity limitEntity,
-                              String user) {
+  public LimitEntity getLimit(LimitEntity limitEntity) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", limitEntity.getVendorLicenseModelId(),
-            "EP/LKGId", limitEntity.getEpLkgId());
+        "EP/LKGId", limitEntity.getEpLkgId());
 
-    limitEntity.setVersion(VersioningUtil.resolveVersion(limitEntity.getVersion(),
-            getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Read,
-                    user), user));
-    if(!isLimitPresent(limitEntity)){
+    if (!isLimitPresent(limitEntity)) {
       VersioningUtil
-              .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+          .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
     }
     LimitEntity retrieved = limitDao.get(limitEntity);
     VersioningUtil
-            .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+        .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
 
     mdcDataDebugMessage.debugExitMessage("VLM id", limitEntity.getVendorLicenseModelId(),
-            "EP/LKGId", limitEntity.getEpLkgId());
+        "EP/LKGId", limitEntity.getEpLkgId());
     return retrieved;
   }
 
   /**
    * update Parent of limit (EP/LKG) versionuuid when limit is modified so that limit updates are
    * captured in VLM XML
-   * @param limit
-   * @param user
    */
-  private void updateParentForLimit(LimitEntity limit, String user) {
+  private void updateParentForLimit(LimitEntity limit) {
     mdcDataDebugMessage.debugEntryMessage("VLM id", limit.getVendorLicenseModelId(),
-            "EP/LKGId", limit.getEpLkgId(), "Limit Parent ", limit.getParent());
-    if ("EntitlementPool".equals(limit.getParent()) ) {
+        "EP/LKGId", limit.getEpLkgId(), "Limit Parent ", limit.getParent());
+    if ("EntitlementPool".equals(limit.getParent())) {
       EntitlementPoolEntity entitlementPoolEntity =
-              entitlementPoolDao.get(new EntitlementPoolEntity(limit.getVendorLicenseModelId(),
-                      limit.getVersion(), limit.getEpLkgId()));
-      vendorLicenseFacade.updateEntitlementPool(entitlementPoolEntity, user);
+          entitlementPoolDao.get(new EntitlementPoolEntity(limit.getVendorLicenseModelId(),
+              limit.getVersion(), limit.getEpLkgId()));
+      vendorLicenseFacade.updateEntitlementPool(entitlementPoolEntity);
     }
 
     if ("LicenseKeyGroup".equals(limit.getParent())) {
       LicenseKeyGroupEntity licenseKeyGroupEntity = licenseKeyGroupDao.get(
-              new LicenseKeyGroupEntity(limit.getVendorLicenseModelId(), limit.getVersion(),
-                      limit.getEpLkgId()));
-      vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroupEntity, user);
+          new LicenseKeyGroupEntity(limit.getVendorLicenseModelId(), limit.getVersion(),
+              limit.getEpLkgId()));
+      vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroupEntity);
     }
 
     mdcDataDebugMessage.debugEntryMessage("VLM id", limit.getVendorLicenseModelId(),
-            "EP/LKGId", limit.getEpLkgId(), "Limit Parent ", limit.getParent());
+        "EP/LKGId", limit.getEpLkgId(), "Limit Parent ", limit.getParent());
   }
 
   protected void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
@@ -954,8 +722,8 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     if (featureGroupIds != null) {
       for (String featureGroupId : featureGroupIds) {
         featureGroupDao.addReferencingLicenseAgreement(
-                new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
-                        licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
+            new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
+                licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
       }
     }
   }
@@ -965,8 +733,8 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     if (featureGroupIds != null) {
       for (String featureGroupId : featureGroupIds) {
         featureGroupDao.removeReferencingLicenseAgreement(
-                new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
-                        licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
+            new FeatureGroupEntity(licenseAgreement.getVendorLicenseModelId(),
+                licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId());
       }
     }
   }
@@ -976,8 +744,8 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     if (licenseKeyGroupIds != null) {
       for (String licenseKeyGroupId : licenseKeyGroupIds) {
         licenseKeyGroupDao.addReferencingFeatureGroup(
-                new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
-                        featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
+            new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
+                featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
       }
     }
   }
@@ -987,8 +755,8 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     if (licenseKeyGroupIds != null) {
       for (String licenseKeyGroupId : licenseKeyGroupIds) {
         licenseKeyGroupDao.removeReferencingFeatureGroup(
-                new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
-                        featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
+            new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(),
+                featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId());
       }
     }
   }
@@ -998,8 +766,8 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     if (entitlementPoolIds != null) {
       for (String entitlementPoolId : entitlementPoolIds) {
         entitlementPoolDao.addReferencingFeatureGroup(
-                new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
-                        featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
+            new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
+                featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
       }
     }
   }
@@ -1009,38 +777,19 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
     if (entitlementPoolIds != null) {
       for (String entitlementPoolId : entitlementPoolIds) {
         entitlementPoolDao.removeReferencingFeatureGroup(
-                new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
-                        featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
+            new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(),
+                featureGroup.getVersion(), entitlementPoolId), featureGroup.getId());
       }
     }
   }
 
-  protected VersionInfo getVersionInfo(String vendorLicenseModelId, VersionableEntityAction action,
-                                       String user) {
-    return vendorLicenseFacade.getVersionInfo(vendorLicenseModelId, action, user);
-  }
-
-  protected LicenseAgreementEntity createLicenseAgreementForList(String vlmId, Version version,
-                                                                 String user) {
-    return new LicenseAgreementEntity(vlmId, VersioningUtil
-            .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user), user),
-            null);
-  }
-
-  protected void updateUniqueName(String uniqueValueType ,String oldName, String newName,String ...
-          context) {
+  protected void updateUniqueName(String uniqueValueType, String oldName, String newName, String...
+      context) {
     UniqueValueUtil
-            .updateUniqueValue(uniqueValueType, oldName, newName,context);
+        .updateUniqueValue(uniqueValueType, oldName, newName, context);
   }
 
-  protected void deleteUniqueName(String uniqueValueType,String ... uniqueCombination) {
+  protected void deleteUniqueName(String uniqueValueType, String... uniqueCombination) {
     UniqueValueUtil.deleteUniqueValue(uniqueValueType, uniqueCombination);
   }
-
-  protected Version resloveVersion(String vlmId,Version requestedVersion, VersionInfo versionInfo,
-                                   String user){
-    return VersioningUtil.resolveVersion(null,
-            getVersionInfo(vlmId, VersionableEntityAction.Write, user), user);
-  }
-
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java
index 5d9729de53..c005e9696f 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java
@@ -20,41 +20,6 @@
 
 package org.openecomp.sdc.vendorlicense;
 
-import org.openecomp.core.utilities.CommonMethods;
-import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction;
-import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime;
-import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm;
-import org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther;
-import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope;
-import org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit;
-import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
-import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
-import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
-import org.openecomp.sdc.vendorlicense.licenseartifacts.VendorLicenseArtifactsService;
-import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
-import org.openecomp.sdc.vendorsoftwareproduct.impl.VendorSoftwareProductManagerImpl;
-import org.openecomp.sdc.versioning.VersioningManager;
-import org.openecomp.sdc.versioning.VersioningManagerFactory;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
-import org.testng.annotations.BeforeMethod;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE;
-
 /**
  * Created by  Katyr on 29-May-16
  */
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java
index 07fdeeeee8..0197dd9d28 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java
@@ -20,17 +20,11 @@
 
 package org.openecomp.sdc.vendorlicense;
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.verify;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.vendorlicense.dao.LimitDao;
 import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction;
 import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
@@ -45,19 +39,19 @@ import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
-public class LimitTest {
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
 
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+public class LimitTest {
 
-  private  final String USER1 = "limitTestUser1";
-  private  final String LT1_NAME = "LT1 name";
+  private final String USER1 = "limitTestUser1";
+  private final String LT1_NAME = "LT1 name";
 
   private static final String VLM_ID = "VLM_ID";
   private static final Version VERSION = new Version(0, 1);
@@ -76,8 +70,8 @@ public class LimitTest {
   private VendorLicenseManagerImpl vendorLicenseManagerImpl;
 
   public static LimitEntity createLimitEntity(String name, LimitType type, String description,
-                                       Version version, String metric,
-                                       AggregationFunction aggregationFunction, int unit,
+                                              Version version, String metric,
+                                              AggregationFunction aggregationFunction, int unit,
                                               String time) {
     LimitEntity limitEntity = new LimitEntity();
     limitEntity.setName(name);
@@ -92,22 +86,22 @@ public class LimitTest {
   }
 
   @BeforeMethod
-  public void setUp() {
+  public void setUp() throws Exception {
     MockitoAnnotations.initMocks(this);
   }
 
   @Test
   public void testUpdateLimit() {
     Version version = new Version();
-    LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
-        "Core",AggregationFunction.Average,10,"Hour");
-    LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
-        "Tokens",AggregationFunction.Peak,12,"Month");
+    LimitEntity limitEntity1 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version,
+        "Core", AggregationFunction.Average, 10, "Hour");
+    LimitEntity limitEntity2 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version,
+        "Tokens", AggregationFunction.Peak, 12, "Month");
     VersionInfo info = new VersionInfo();
     info.getViewableVersions().add(version);
     info.setActiveVersion(version);
 
-    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+    /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/
     doReturn(true).when(limitDao).isLimitPresent(anyObject());
     doReturn(limitEntity1).when(limitDao).get(anyObject());
 
@@ -116,27 +110,28 @@ public class LimitTest {
     limitEntityList.add(limitEntity2);
     limitEntity1.setId("1234");
     limitEntity2.setId("1234");
-    doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(),anyObject(),
-        anyObject(),anyObject());
+    doReturn(limitEntityList).when(vendorLicenseFacade)
+        .listLimits(anyObject(), anyObject(), anyObject());
 
-    vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1);
+    vendorLicenseManagerImpl.updateLimit(limitEntity2);
 
-    verify(vendorLicenseFacade).updateLimit(anyObject(), anyObject());
+    verify(vendorLicenseFacade).updateLimit(anyObject());
   }
 
   @Test
   public void testUpdateLimitErrorWithSameNameType() {
     try {
       Version version = new Version();
-      LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
-          "Core",AggregationFunction.Average,10,"Hour");
-      LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
-          "Tokens",AggregationFunction.Peak,12,"Month");
+      LimitEntity limitEntity1 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version,
+          "Core", AggregationFunction.Average, 10, "Hour");
+      LimitEntity limitEntity2 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version,
+          "Tokens", AggregationFunction.Peak, 12, "Month");
       VersionInfo info = new VersionInfo();
       info.getViewableVersions().add(version);
       info.setActiveVersion(version);
 
-      doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+/*      doReturn(info).when(vendorLicenseFacade)
+          .getVersionInfo(anyObject(), anyObject(), anyObject());*/
       doReturn(limitEntity1).when(limitDao).get(anyObject());
 
       List<LimitEntity> limitEntityList = new ArrayList<>();
@@ -144,13 +139,12 @@ public class LimitTest {
       limitEntityList.add(limitEntity2);
       limitEntity1.setId("1234");
       limitEntity2.setId("9632");
-      doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(),anyObject(),
-          anyObject(),anyObject());
+      doReturn(limitEntityList).when(vendorLicenseFacade)
+          .listLimits(anyObject(), anyObject(), anyObject());
 
-      vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1);
+      vendorLicenseManagerImpl.updateLimit(limitEntity2);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(),
           VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
     }
@@ -159,13 +153,13 @@ public class LimitTest {
   @Test
   public void testDeleteLimit() {
     Version version = new Version();
-    LimitEntity limitEntity = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
-            "Core",AggregationFunction.Average,10,"Hour");
+    LimitEntity limitEntity = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version,
+        "Core", AggregationFunction.Average, 10, "Hour");
     VersionInfo info = new VersionInfo();
     info.getViewableVersions().add(version);
     info.setActiveVersion(version);
 
-    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+    /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/
     doReturn(true).when(limitDao).isLimitPresent(anyObject());
     doReturn(limitEntity).when(limitDao).get(anyObject());
 
@@ -173,27 +167,28 @@ public class LimitTest {
     limitEntityList.add(limitEntity);
     limitEntity.setId("1234");
 
-    vendorLicenseManagerImpl.deleteLimit(limitEntity,LT1_NAME);
+    vendorLicenseManagerImpl.deleteLimit(limitEntity);
 
-    verify(vendorLicenseManagerImpl).deleteLimit(anyObject(), anyObject());
+    verify(vendorLicenseManagerImpl).deleteLimit(anyObject());
   }
 
   @Test
   public void testUpdateLimitErrorWithInvalidId() {
     try {
       Version version = new Version();
-      LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
-          "Core",AggregationFunction.Average,10,"Hour");
-      LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
-          "Tokens",AggregationFunction.Peak,12,"Month");
+      LimitEntity limitEntity1 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version,
+          "Core", AggregationFunction.Average, 10, "Hour");
+      LimitEntity limitEntity2 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version,
+          "Tokens", AggregationFunction.Peak, 12, "Month");
       VersionInfo info = new VersionInfo();
       info.getViewableVersions().add(version);
       info.setActiveVersion(version);
 
-      doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+/*      doReturn(info).when(vendorLicenseFacade)
+          .getVersionInfo(anyObject(), anyObject(), anyObject());*/
       doReturn(null).when(limitDao).get(anyObject());
 
-      vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1);
+      vendorLicenseManagerImpl.updateLimit(limitEntity2);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(),
@@ -206,14 +201,14 @@ public class LimitTest {
     doReturn(Arrays.asList(
         createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID),
         createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT2_ID)))
-        .when(vendorLicenseFacade).listLimits(VLM_ID, VERSION, EPLKG_ID, USER1);
+        .when(vendorLicenseFacade).listLimits(VLM_ID, VERSION, EPLKG_ID);
 
     final Collection<LimitEntity> limits =
-        vendorLicenseManagerImpl.listLimits(VLM_ID, VERSION, EPLKG_ID, USER1);
+        vendorLicenseManagerImpl.listLimits(VLM_ID, VERSION, EPLKG_ID);
     Assert.assertEquals(limits.size(), 2);
     for (LimitEntity limit : limits) {
       Assert.assertEquals(limit.getName(),
-          LIMIT1_ID.equals(limit.getId()) ? LIMIT1_ID+" name" : LIMIT2_ID+" name" );
+          LIMIT1_ID.equals(limit.getId()) ? LIMIT1_ID + " name" : LIMIT2_ID + " name");
     }
   }
 
@@ -224,10 +219,10 @@ public class LimitTest {
     info.getViewableVersions().add(VERSION);
     info.setActiveVersion(VERSION);
 
-    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+    /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/
 
-    vendorLicenseManagerImpl.createLimit(expected, USER1);
-    verify(vendorLicenseFacade).createLimit(expected,USER1);
+    vendorLicenseManagerImpl.createLimit(expected);
+    verify(vendorLicenseFacade).createLimit(expected);
   }
 
   @Test
@@ -241,20 +236,19 @@ public class LimitTest {
 
     List<LimitEntity> vfcImageList = new ArrayList<LimitEntity>();
     vfcImageList.add(expectedDiffName);
-    doReturn(vfcImageList).when(vendorLicenseFacade).listLimits(anyObject(), anyObject(), anyObject(),
-        anyObject());
+    doReturn(vfcImageList).when(vendorLicenseFacade)
+        .listLimits(anyObject(), anyObject(), anyObject());
 
     VersionInfo info = new VersionInfo();
     info.getViewableVersions().add(VERSION);
     info.setActiveVersion(VERSION);
 
-    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+/*    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/
 
     try {
-      vendorLicenseManagerImpl.createLimit(expected, USER1);
+      vendorLicenseManagerImpl.createLimit(expected);
       Assert.fail();
-    }
-    catch (CoreException ex) {
+    } catch (CoreException ex) {
       Assert.assertEquals(ex.code().id(),
           VendorLicenseErrorCodes.DUPLICATE_LIMIT_NAME_NOT_ALLOWED);
     }
@@ -267,13 +261,14 @@ public class LimitTest {
     info.getViewableVersions().add(VERSION);
     info.setActiveVersion(VERSION);
 
-    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+    /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/
 
     try {
-      vendorLicenseManagerImpl.getLimit(limit , USER1);
+      vendorLicenseManagerImpl.getLimit(limit);
       Assert.fail();
     } catch (CoreException exception) {
-      Assert.assertEquals(exception.code().id(), VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+      Assert.assertEquals(exception.code().id(),
+          VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
     }
   }
 
@@ -293,10 +288,10 @@ public class LimitTest {
     info.getViewableVersions().add(VERSION);
     info.setActiveVersion(VERSION);
 
-    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+    /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/
 
     LimitEntity actual = createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID);
-    vendorLicenseManagerImpl.getLimit(actual, USER1);
+    vendorLicenseManagerImpl.getLimit(actual);
     Assert.assertEquals(actual.getId(), expected.getId());
     Assert.assertEquals(actual.getName(), expected.getName());
     Assert.assertEquals(actual.getUnit(), expected.getUnit());
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java
index ab6262d8ca..e3719ab515 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java
@@ -1,39 +1,5 @@
 package org.openecomp.sdc.vendorlicense;
 
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
-import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao;
-import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao;
-import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
-import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
-import org.openecomp.sdc.vendorlicense.facade.impl.VendorLicenseFacadeImpl;
-import org.openecomp.sdc.versioning.VersioningManager;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.testng.Assert;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.openecomp.sdc.vendorlicense.errors.UncompletedVendorLicenseModelErrorType.SUBMIT_UNCOMPLETED_VLM_MSG_FG_MISSING_EP;
-import static org.openecomp.sdc.vendorlicense.errors.UncompletedVendorLicenseModelErrorType.SUBMIT_UNCOMPLETED_VLM_MSG_LA_MISSING_FG;
-
 /**
  * This test just verifies Feature Group Get and List APIs.
  */
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java
index 178d05e6c8..57d22544ad 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java
@@ -28,12 +28,16 @@ import org.mockito.Spy;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
 import org.openecomp.sdc.vendorlicense.dao.LimitDao;
-import org.openecomp.sdc.vendorlicense.dao.types.*;
+import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction;
+import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric;
+import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime;
+import org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther;
+import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope;
+import org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit;
 import org.openecomp.sdc.vendorlicense.errors.VendorLicenseErrorCodes;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
@@ -41,7 +45,6 @@ import org.testng.annotations.Test;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
@@ -54,353 +57,323 @@ import static org.mockito.Mockito.verify;
 
 public class EntitlementPoolTest {
 
-    //JUnit Test Cases using Mockito
-    private  final String USER1 = "epTestUser1";
-    private  final String EP1_NAME = "EP1 name";
-    private  final String EP2_NAME = "EP2 name";
-    private  final String LT1_NAME = "LT1 name";
-    private static String vlm1_id = "vlm1_id";
-    private static String ep1_id = "ep1_id";
-    private static String ep2_id = "ep2_id";
-    public static final Version VERSION01 = new Version(0, 1);
-
-    @Mock
-    private VendorLicenseFacade vendorLicenseFacade;
-
-    @Mock
-    private EntitlementPoolDao entitlementPoolDao;
-    @Mock
-    private LimitDao limitDao;
-
-    @InjectMocks
-    @Spy
-    private VendorLicenseManagerImpl vendorLicenseManagerImpl;
-
-    public EntitlementPoolEntity createEntitlementPool(String vlmId, Version version,String id,
-                                                       String name, String desc, int threshold,
-                                                       ThresholdUnit thresholdUnit,
-                                                       EntitlementMetric entitlementMetricChoice,
-                                                       String entitlementMetricOther,
-                                                       String increments,
-                                                       AggregationFunction aggregationFunctionChoice,
-                                                       String aggregationFunctionOther,
-                                                       Set<OperationalScope> operationalScopeChoices,
-                                                       String operationalScopeOther,
-                                                       EntitlementTime timeChoice,
-                                                       String timeOther, String sku) {
-        EntitlementPoolEntity entitlementPool = new EntitlementPoolEntity();
-        entitlementPool.setVendorLicenseModelId(vlmId);
-        entitlementPool.setId(id);
-        entitlementPool.setVersion(version);
-        entitlementPool.setName(name);
-        entitlementPool.setDescription(desc);
-        entitlementPool.setThresholdValue(threshold);
-        entitlementPool.setThresholdUnit(thresholdUnit);
-        entitlementPool.setIncrements(increments);
-        entitlementPool.setOperationalScope(
-            new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther));
-        return entitlementPool;
-    }
-
-    @BeforeMethod
-    public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
-    }
+  //JUnit Test Cases using Mockito
+  private final String USER1 = "epTestUser1";
+  private final String EP1_NAME = "EP1 name";
+  private final String EP2_NAME = "EP2 name";
+  private final String LT1_NAME = "LT1 name";
+  private static String vlm1_id = "vlm1_id";
+  private static String ep1_id = "ep1_id";
+  private static String ep2_id = "ep2_id";
+  public static final Version VERSION01 = new Version(0, 1);
+
+  @Mock
+  private VendorLicenseFacade vendorLicenseFacade;
+
+  @Mock
+  private EntitlementPoolDao entitlementPoolDao;
+  @Mock
+  private LimitDao limitDao;
+
+  @InjectMocks
+  @Spy
+  private VendorLicenseManagerImpl vendorLicenseManagerImpl;
+
+  public EntitlementPoolEntity createEntitlementPool(String vlmId, Version version, String id,
+                                                     String name, String desc, int threshold,
+                                                     ThresholdUnit thresholdUnit,
+                                                     EntitlementMetric entitlementMetricChoice,
+                                                     String entitlementMetricOther,
+                                                     String increments,
+                                                     AggregationFunction aggregationFunctionChoice,
+                                                     String aggregationFunctionOther,
+                                                     Set<OperationalScope> operationalScopeChoices,
+                                                     String operationalScopeOther,
+                                                     EntitlementTime timeChoice,
+                                                     String timeOther, String sku) {
+    EntitlementPoolEntity entitlementPool = new EntitlementPoolEntity();
+    entitlementPool.setVendorLicenseModelId(vlmId);
+    entitlementPool.setId(id);
+    entitlementPool.setVersion(version);
+    entitlementPool.setName(name);
+    entitlementPool.setDescription(desc);
+    entitlementPool.setThresholdValue(threshold);
+    entitlementPool.setThresholdUnit(thresholdUnit);
+    entitlementPool.setIncrements(increments);
+    entitlementPool.setOperationalScope(
+        new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther));
+    return entitlementPool;
+  }
 
-    @Test
-    public void createTest() {
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
-        EntitlementPoolEntity ep2 =
-            createEntitlementPool("vlm1Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, ThresholdUnit
-                    .Absolute,
-                EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-        ep2.setStartDate(LocalDate.now().format(formatter));
-        ep2.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
 
-        vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1);
-        verify(vendorLicenseFacade).createEntitlementPool(ep2,USER1);
+  @Test
+  public void createTest() {
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
+    EntitlementPoolEntity ep2 =
+        createEntitlementPool("vlm1Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, ThresholdUnit
+                .Absolute,
+            EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+    ep2.setStartDate(LocalDate.now().format(formatter));
+    ep2.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
 
-    }
+    vendorLicenseManagerImpl.createEntitlementPool(ep2);
+    verify(vendorLicenseFacade).createEntitlementPool(ep2);
 
-    @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
-        "license model with id vlm1_id has invalid date range.")
-    public void createWithInvalidStartExpiryDateTest() {
+  }
 
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
-        EntitlementPoolEntity ep2 =
-            createEntitlementPool("vlm2Id", null, ep1_id,EP1_NAME, "EP2 dec", 70,
-                ThresholdUnit.Absolute,
-                EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-        ep2.setStartDate(LocalDate.now().format(formatter));
-        ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
-        ep2.setVendorLicenseModelId(vlm1_id);
-        vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId();
-        Assert.fail();
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
+      "license model with id vlm1_id has invalid date range.")
+  public void createWithInvalidStartExpiryDateTest() {
 
-    }
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
+    EntitlementPoolEntity ep2 =
+        createEntitlementPool("vlm2Id", null, ep1_id, EP1_NAME, "EP2 dec", 70,
+            ThresholdUnit.Absolute,
+            EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+    ep2.setStartDate(LocalDate.now().format(formatter));
+    ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
+    ep2.setVendorLicenseModelId(vlm1_id);
+    vendorLicenseManagerImpl.createEntitlementPool(ep2).getId();
+    Assert.fail();
 
-    @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
-        "license model with id vlm1_id has invalid date range.")
-    public void createWithoutStartDateTest() {
+  }
 
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
-        EntitlementPoolEntity ep2 =
-            createEntitlementPool("vlm3Id", null, ep1_id,EP1_NAME, "EP2 dec", 70,
-                ThresholdUnit.Absolute,
-                EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-        ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
-        ep2.setVendorLicenseModelId(vlm1_id);
-        vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId();
-        Assert.fail();
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
+      "license model with id vlm1_id has invalid date range.")
+  public void createWithoutStartDateTest() {
 
-    }
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
+    EntitlementPoolEntity ep2 =
+        createEntitlementPool("vlm3Id", null, ep1_id, EP1_NAME, "EP2 dec", 70,
+            ThresholdUnit.Absolute,
+            EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+    ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
+    ep2.setVendorLicenseModelId(vlm1_id);
+    vendorLicenseManagerImpl.createEntitlementPool(ep2).getId();
+    Assert.fail();
 
-    @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
-        "license model with id vlm1_id has invalid date range.")
-    public void createWithSameStartExpiryDateTest() {
+  }
 
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
-        EntitlementPoolEntity ep2 =
-            createEntitlementPool("vlm4Id", null, ep1_id,EP1_NAME, "EP2 dec", 70,
-                ThresholdUnit.Absolute,
-                EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-        ep2.setStartDate(LocalDate.now().format(formatter));
-        ep2.setExpiryDate(LocalDate.now().format(formatter));
-        ep2.setVendorLicenseModelId(vlm1_id);
-        vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId();
-        Assert.fail();
-    }
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
+      "license model with id vlm1_id has invalid date range.")
+  public void createWithSameStartExpiryDateTest() {
 
-    @Test
-    public void testUpdate() {
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
-        EntitlementPoolEntity ep2 =
-            createEntitlementPool(vlm1_id, VERSION01, ep1_id,EP1_NAME, "EP2 dec", 70,
-                ThresholdUnit
-                    .Absolute,
-                EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-        ep2.setStartDate(LocalDate.now().minusDays(3L).format(formatter));
-        ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
+    EntitlementPoolEntity ep2 =
+        createEntitlementPool("vlm4Id", null, ep1_id, EP1_NAME, "EP2 dec", 70,
+            ThresholdUnit.Absolute,
+            EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+    ep2.setStartDate(LocalDate.now().format(formatter));
+    ep2.setExpiryDate(LocalDate.now().format(formatter));
+    ep2.setVendorLicenseModelId(vlm1_id);
+    vendorLicenseManagerImpl.createEntitlementPool(ep2).getId();
+    Assert.fail();
+  }
 
-        VersionInfo info = new VersionInfo();
-        info.getViewableVersions().add(VERSION01);
-        info.setActiveVersion(VERSION01);
-        doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+  @Test
+  public void testUpdate() {
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
+    EntitlementPoolEntity ep2 =
+        createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP2 dec", 70,
+            ThresholdUnit
+                .Absolute,
+            EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+    ep2.setStartDate(LocalDate.now().minusDays(3L).format(formatter));
+    ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
 
-        vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
-        verify(vendorLicenseFacade).updateEntitlementPool(ep2,USER1);
-        verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01);
-    }
+    vendorLicenseManagerImpl.updateEntitlementPool(ep2);
+  }
 
-    @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
-        "license model with id vlm1_id has invalid date range.")
-    public void updateWithInvalidStartExpiryDateTest() {
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " +
+      "license model with id vlm1_id has invalid date range.")
+  public void updateWithInvalidStartExpiryDateTest() {
 
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
-        EntitlementPoolEntity ep2 =
-            createEntitlementPool("vlm2Id", null, ep1_id,EP1_NAME, "EP2 dec", 70,
-                ThresholdUnit.Absolute,
-                EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-        ep2.setStartDate(LocalDate.now().format(formatter));
-        ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
-        ep2.setVendorLicenseModelId(vlm1_id);
-        vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
-        Assert.fail();
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
+    EntitlementPoolEntity ep2 =
+        createEntitlementPool("vlm2Id", null, ep1_id, EP1_NAME, "EP2 dec", 70,
+            ThresholdUnit.Absolute,
+            EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+    ep2.setStartDate(LocalDate.now().format(formatter));
+    ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
+    ep2.setVendorLicenseModelId(vlm1_id);
+    vendorLicenseManagerImpl.updateEntitlementPool(ep2);
+    Assert.fail();
 
-    }
+  }
 
-    @Test
-    public void updateWithoutStartDateTest() {
-        try {
+  @Test
+  public void updateWithoutStartDateTest() {
+    try {
 
-            Set<OperationalScope> opScopeChoices;
-            opScopeChoices = new HashSet<>();
-            opScopeChoices.add(OperationalScope.Core);
-            opScopeChoices.add(OperationalScope.CPU);
-            opScopeChoices.add(OperationalScope.Network_Wide);
-            EntitlementPoolEntity ep2 =
-                createEntitlementPool("vlm3Id", null, ep1_id,EP1_NAME, "EP2 dec", 70,
-                    ThresholdUnit.Absolute,
-                    EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                    opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-            ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
-            vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
-            Assert.fail();
-        } catch (CoreException exception) {
-            Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
-        }
+      Set<OperationalScope> opScopeChoices;
+      opScopeChoices = new HashSet<>();
+      opScopeChoices.add(OperationalScope.Core);
+      opScopeChoices.add(OperationalScope.CPU);
+      opScopeChoices.add(OperationalScope.Network_Wide);
+      EntitlementPoolEntity ep2 =
+          createEntitlementPool("vlm3Id", null, ep1_id, EP1_NAME, "EP2 dec", 70,
+              ThresholdUnit.Absolute,
+              EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average,
+              null,
+              opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+      DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+      ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
+      vendorLicenseManagerImpl.updateEntitlementPool(ep2);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
     }
+  }
 
-    @Test
-    public void updateWithSameStartExpiryDateTest() {
-        try {
+  @Test
+  public void updateWithSameStartExpiryDateTest() {
+    try {
 
-            Set<OperationalScope> opScopeChoices;
-            opScopeChoices = new HashSet<>();
-            opScopeChoices.add(OperationalScope.Core);
-            opScopeChoices.add(OperationalScope.CPU);
-            opScopeChoices.add(OperationalScope.Network_Wide);
-            EntitlementPoolEntity ep2 =
-                createEntitlementPool("vlm4Id", null, ep1_id,EP1_NAME, "EP2 dec", 70,
-                    ThresholdUnit.Absolute,
-                    EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
-                    opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-            ep2.setStartDate(LocalDate.now().format(formatter));
-            ep2.setExpiryDate(LocalDate.now().format(formatter));
-            vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
-            Assert.fail();
-        } catch (CoreException exception) {
-            Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
-        }
+      Set<OperationalScope> opScopeChoices;
+      opScopeChoices = new HashSet<>();
+      opScopeChoices.add(OperationalScope.Core);
+      opScopeChoices.add(OperationalScope.CPU);
+      opScopeChoices.add(OperationalScope.Network_Wide);
+      EntitlementPoolEntity ep2 =
+          createEntitlementPool("vlm4Id", null, ep1_id, EP1_NAME, "EP2 dec", 70,
+              ThresholdUnit.Absolute,
+              EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average,
+              null,
+              opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+      DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+      ep2.setStartDate(LocalDate.now().format(formatter));
+      ep2.setExpiryDate(LocalDate.now().format(formatter));
+      vendorLicenseManagerImpl.updateEntitlementPool(ep2);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
     }
+  }
 
-    @Test
-    public void deleteEntitlementPoolTest() {
-
-        VersionInfo versionInfo = new VersionInfo();
-        versionInfo.setActiveVersion(VERSION01);
-        versionInfo.setLockingUser(USER1);
-        ArrayList<Version> viewable = new ArrayList<Version>();
-        viewable.add(VERSION01);
-        versionInfo.setViewableVersions(viewable);
-
-        doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id,
-            VersionableEntityAction.Write, USER1);
-
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
-
-        EntitlementPoolEntity entitlementPool =
-            createEntitlementPool(vlm1_id,VERSION01, ep1_id,EP1_NAME, "EP2 dec", 70,
-                ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric2", "inc2",
-                AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
-        entitlementPool.setStartDate(LocalDate.now().format(formatter));
-        entitlementPool.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
-
-        doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject());
-
-        doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id,VERSION01,ep1_id,USER1);
-
-        doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(),anyObject(),
-            anyObject(),anyObject());
+  @Test
+  public void deleteEntitlementPoolTest() {
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
 
-        vendorLicenseManagerImpl.deleteEntitlementPool(entitlementPool, USER1);
+    EntitlementPoolEntity entitlementPool =
+        createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP2 dec", 70,
+            ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric2", "inc2",
+            AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+    entitlementPool.setStartDate(LocalDate.now().format(formatter));
+    entitlementPool.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
 
-        verify(entitlementPoolDao).delete(entitlementPool);
-        verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01);
+    doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject());
 
-    }
+    doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id, VERSION01, ep1_id);
 
-    @Test
-    public void testGetEntitlementPool(){
+    doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(), anyObject(),
+        anyObject(), anyObject());
 
-        VersionInfo versionInfo = new VersionInfo();
-        versionInfo.setActiveVersion(VERSION01);
-        versionInfo.setLockingUser(USER1);
-        ArrayList<Version> viewable = new ArrayList<Version>();
-        viewable.add(VERSION01);
-        versionInfo.setViewableVersions(viewable);
-        versionInfo.setActiveVersion(VERSION01);
+    vendorLicenseManagerImpl.deleteEntitlementPool(entitlementPool);
 
-        doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id,
-            VersionableEntityAction.Read, USER1);
+    verify(entitlementPoolDao).delete(entitlementPool);
+  }
 
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
+  @Test
+  public void testGetEntitlementPool() {
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
 
-        EntitlementPoolEntity entitlementPool =
-            createEntitlementPool(vlm1_id,VERSION01, ep1_id,EP1_NAME, "EP2 dec", 70,
-                ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric2", "inc2",
-                AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
-        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
+    EntitlementPoolEntity entitlementPool =
+        createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP2 dec", 70,
+            ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric2", "inc2",
+            AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
 
-        entitlementPool.setStartDate(LocalDateTime.now().format(formatter));
-        entitlementPool.setExpiryDate(LocalDateTime.now().plusDays(1L).format(formatter));
+    entitlementPool.setStartDate(LocalDateTime.now().format(formatter));
+    entitlementPool.setExpiryDate(LocalDateTime.now().plusDays(1L).format(formatter));
 
-        doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject());
+    doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject());
 
-        EntitlementPoolEntity retrived = vendorLicenseManagerImpl.getEntitlementPool
-            (entitlementPool,USER1);
+    EntitlementPoolEntity retrived = vendorLicenseManagerImpl.getEntitlementPool(entitlementPool);
 
-        Assert.assertEquals(retrived.getId(),entitlementPool.getId());
-        Assert.assertEquals(retrived.getVendorLicenseModelId(),entitlementPool.getVendorLicenseModelId());
-        Assert.assertEquals(retrived.getVersion(),entitlementPool.getVersion());
-    }
+    Assert.assertEquals(retrived.getId(), entitlementPool.getId());
+    Assert.assertEquals(retrived.getVendorLicenseModelId(),
+        entitlementPool.getVendorLicenseModelId());
+    Assert.assertEquals(retrived.getVersion(), entitlementPool.getVersion());
+  }
 
-    @Test
-    public void testListEntitlmentPool(){
+  @Test
+  public void testListEntitlmentPool() {
 
-        Set<OperationalScope> opScopeChoices;
-        opScopeChoices = new HashSet<>();
-        opScopeChoices.add(OperationalScope.Core);
-        opScopeChoices.add(OperationalScope.CPU);
-        opScopeChoices.add(OperationalScope.Network_Wide);
+    Set<OperationalScope> opScopeChoices;
+    opScopeChoices = new HashSet<>();
+    opScopeChoices.add(OperationalScope.Core);
+    opScopeChoices.add(OperationalScope.CPU);
+    opScopeChoices.add(OperationalScope.Network_Wide);
 
-        doReturn(Arrays.asList(
-            createEntitlementPool(vlm1_id,VERSION01, ep1_id, EP1_NAME,"EP1 dec", 70,
-                ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric1",
-                "inc1", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time1", "sku1"),
-            createEntitlementPool(vlm1_id,VERSION01, ep2_id, EP2_NAME,"EP2 dec", 70,
-                ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric2",
-                "inc2", AggregationFunction.Average, null,
-                opScopeChoices, null, EntitlementTime.Other, "time2", "sku2")))
-            .when(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01, USER1);
-
-        Collection<EntitlementPoolEntity> EPs =
-            vendorLicenseManagerImpl.listEntitlementPools(vlm1_id, VERSION01, USER1);
-
-        verify(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01, USER1);
-        Assert.assertEquals(EPs.size(), 2);
-        EPs.forEach(ep -> Assert.assertTrue(ep.getId().matches(ep1_id + "|" + ep2_id)));
-    }
+    doReturn(Arrays.asList(
+        createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP1 dec", 70,
+            ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric1",
+            "inc1", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time1", "sku1"),
+        createEntitlementPool(vlm1_id, VERSION01, ep2_id, EP2_NAME, "EP2 dec", 70,
+            ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric2",
+            "inc2", AggregationFunction.Average, null,
+            opScopeChoices, null, EntitlementTime.Other, "time2", "sku2")))
+        .when(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01);
+
+    Collection<EntitlementPoolEntity> EPs =
+        vendorLicenseManagerImpl.listEntitlementPools(vlm1_id, VERSION01);
+
+    verify(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01);
+    Assert.assertEquals(EPs.size(), 2);
+    EPs.forEach(ep -> Assert.assertTrue(ep.getId().matches(ep1_id + "|" + ep2_id)));
+  }
 
 
   /*  @Test
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java
index dd3560615e..b9eacc3e6f 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java
@@ -21,35 +21,27 @@
 
 package org.openecomp.sdc.vendorlicense.impl;
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
 import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
-import org.openecomp.sdc.vendorlicense.dao.*;
-import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther;
+import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
+import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao;
+import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao;
+import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
+import org.openecomp.sdc.vendorlicense.dao.LimitDao;
+import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
 import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
 import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
-import org.openecomp.sdc.vendorlicense.facade.impl.VendorLicenseFacadeImpl;
-import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
 import org.openecomp.sdc.versioning.VersioningManager;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
 import org.testng.Assert;
-import org.testng.AssertJUnit.*;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
@@ -58,7 +50,6 @@ import java.util.Set;
 import static org.mockito.Matchers.anyObject;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 
 /**
@@ -66,272 +57,254 @@ import static org.mockito.Mockito.verify;
  */
 
 public class FeatureGroupTest {
-    //JUnit Test Cases using Mockito
-    private static final Version VERSION01 = new Version(0, 1);
-    private static final Version VERSION10 = new Version(1, 0);
-    private final String FG1_NAME = "FG1 name";
-    private static final String USER1 = "TestUser1";
-    private static final String USER2 = "TestUser2";
-
-    private static String vlm1_id = "vlm1_id";
-    private static String vlm2_id = "vlm2_id";
-    private static String lkg1_id = "lkg1_id";
-    private static String lkg2_id = "lkg2_id";
-    private static String fg1_id = "fg1_id";
-    private static String fg2_id = "fg2_id";
-    private static String ep1_id = "ep1_id";
-    private static String ep2_id = "ep2_id";
-
-    @Mock
-    private VendorLicenseFacade vendorLicenseFacadeMcok;
-
-    @Mock
-    private LimitDao limitDaoMcok;
-    @Mock
-    private ActivityLogManager activityLogManagerMcok;
-
-    @Mock
-    private VendorLicenseModelDao vendorLicenseModelDao;
-
-    @Mock
-    private LicenseAgreementDao licenseAgreementDao;
-
-    @Mock
-    private FeatureGroupDao featureGroupDao;
-
-    @Mock
-    private EntitlementPoolDao entitlementPoolDao;
-
-    @Mock
-    private LicenseKeyGroupDao licenseKeyGroupDao;
-
-    @Mock
-    private VersioningManager versioningManager;
-
-    @InjectMocks
-    @Spy
-    private VendorLicenseManagerImpl vendorLicenseManagerImpl;
-
-    public FeatureGroupEntity updateFeatureGroup(String vlmId, Version version, String id, String name, String desc,
-                                                 String partNumber, String manufacturerReferenceNumber, Set<String>
-                                                     licenseKeyGroupIds, Set<String> entitlementPoolIds, Set<String>
-                                                     referencingLicenseAgreements){
-        FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlmId, version, id);
-        featureGroup.setVendorLicenseModelId(vlmId);
-        featureGroup.setVersion(version);
-        featureGroup.setId(id);
-        featureGroup.setName(name);
-        featureGroup.setDescription(desc);
-        featureGroup.setPartNumber(partNumber);
-        //featureGroup.setManufacturerReferenceNumber(manufacturerReferenceNumber);
-        featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
-        featureGroup.setEntitlementPoolIds(entitlementPoolIds);
-        featureGroup.setReferencingLicenseAgreements(referencingLicenseAgreements);
-
-        return featureGroup;
-    }
-
-    @BeforeMethod
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void testUpdate(){
-        Set<String> licenseKeyGroupIds;
-        licenseKeyGroupIds = new HashSet<>();
-        licenseKeyGroupIds.add("lkg1");
-
-        Set<String> entitlementPoolIds;
-        entitlementPoolIds = new HashSet<>();
-        entitlementPoolIds.add("ep1");
-
-        Set<String> referencingLicenseAgreements;
-        referencingLicenseAgreements = new HashSet<>();
-        referencingLicenseAgreements.add("la1");
-
-        FeatureGroupEntity featureGroupEntity = updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
+  //JUnit Test Cases using Mockito
+  private static final Version VERSION01 = new Version(0, 1);
+  private static final Version VERSION10 = new Version(1, 0);
+  private final String FG1_NAME = "FG1 name";
+  private static final String USER1 = "TestUser1";
+  private static final String USER2 = "TestUser2";
+
+  private static String vlm1_id = "vlm1_id";
+  private static String vlm2_id = "vlm2_id";
+  private static String lkg1_id = "lkg1_id";
+  private static String lkg2_id = "lkg2_id";
+  private static String fg1_id = "fg1_id";
+  private static String fg2_id = "fg2_id";
+  private static String ep1_id = "ep1_id";
+  private static String ep2_id = "ep2_id";
+
+  @Mock
+  private VendorLicenseFacade vendorLicenseFacadeMcok;
+
+  @Mock
+  private LimitDao limitDaoMcok;
+
+  @Mock
+  private VendorLicenseModelDao vendorLicenseModelDao;
+
+  @Mock
+  private LicenseAgreementDao licenseAgreementDao;
+
+  @Mock
+  private FeatureGroupDao featureGroupDao;
+
+  @Mock
+  private EntitlementPoolDao entitlementPoolDao;
+
+  @Mock
+  private LicenseKeyGroupDao licenseKeyGroupDao;
+
+  @Mock
+  private VersioningManager versioningManager;
+
+  @InjectMocks
+  @Spy
+  private VendorLicenseManagerImpl vendorLicenseManagerImpl;
+
+  public FeatureGroupEntity updateFeatureGroup(String vlmId, Version version, String id,
+                                               String name, String desc,
+                                               String partNumber,
+                                               String manufacturerReferenceNumber, Set<String>
+                                                   licenseKeyGroupIds,
+                                               Set<String> entitlementPoolIds, Set<String>
+                                                   referencingLicenseAgreements) {
+    FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlmId, version, id);
+    featureGroup.setVendorLicenseModelId(vlmId);
+    featureGroup.setVersion(version);
+    featureGroup.setId(id);
+    featureGroup.setName(name);
+    featureGroup.setDescription(desc);
+    featureGroup.setPartNumber(partNumber);
+    //featureGroup.setManufacturerReferenceNumber(manufacturerReferenceNumber);
+    featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
+    featureGroup.setEntitlementPoolIds(entitlementPoolIds);
+    featureGroup.setReferencingLicenseAgreements(referencingLicenseAgreements);
+
+    return featureGroup;
+  }
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  public void testUpdate() {
+    Set<String> licenseKeyGroupIds;
+    licenseKeyGroupIds = new HashSet<>();
+    licenseKeyGroupIds.add("lkg1");
+
+    Set<String> entitlementPoolIds;
+    entitlementPoolIds = new HashSet<>();
+    entitlementPoolIds.add("ep1");
+
+    Set<String> referencingLicenseAgreements;
+    referencingLicenseAgreements = new HashSet<>();
+    referencingLicenseAgreements.add("la1");
+
+    FeatureGroupEntity featureGroupEntity =
+        updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
             "partNumber", "MRN", licenseKeyGroupIds, entitlementPoolIds,
             referencingLicenseAgreements);
 
-        doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
+    doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
 
         /*if(featureGroupEntity.getManufacturerReferenceNumber() != null)
             featureGroupDao.update(featureGroupEntity);
         verify(featureGroupDao).update(anyObject());*/
-    }
+  }
 
-    @Test
-    public void testUpdateWithoutManufacturingReferenceNumber(){
-        Set<String> licenseKeyGroupIds;
-        licenseKeyGroupIds = new HashSet<>();
-        licenseKeyGroupIds.add("lkg1");
+  @Test
+  public void testUpdateWithoutManufacturingReferenceNumber() {
+    Set<String> licenseKeyGroupIds;
+    licenseKeyGroupIds = new HashSet<>();
+    licenseKeyGroupIds.add("lkg1");
 
-        Set<String> entitlementPoolIds;
-        entitlementPoolIds = new HashSet<>();
-        entitlementPoolIds.add("ep1");
+    Set<String> entitlementPoolIds;
+    entitlementPoolIds = new HashSet<>();
+    entitlementPoolIds.add("ep1");
 
-        Set<String> referencingLicenseAgreements;
-        referencingLicenseAgreements = new HashSet<>();
-        referencingLicenseAgreements.add("la1");
+    Set<String> referencingLicenseAgreements;
+    referencingLicenseAgreements = new HashSet<>();
+    referencingLicenseAgreements.add("la1");
 
-        FeatureGroupEntity featureGroupEntity = updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
+    FeatureGroupEntity featureGroupEntity =
+        updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
             "partNumber", null, licenseKeyGroupIds, entitlementPoolIds,
             referencingLicenseAgreements);
 
-        doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
+    doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
 
         /*if(featureGroupEntity.getManufacturerReferenceNumber() != null)
             featureGroupDao.update(featureGroupEntity);
         verify(featureGroupDao, never()).update(anyObject());*/
-    }
-
-    @Test
-    public void testListFeatureGroups() {
-        doReturn(Arrays.asList(
-            createFeatureGroup(vlm1_id, VERSION01, fg1_id, "FG1", "FG1 desc", new HashSet<String>(),
-                new HashSet<String>()),
-            createFeatureGroup(vlm1_id, VERSION01, fg2_id, "FG2", "FG2 desc", new HashSet<String>(),
-                new HashSet<String>())))
-            .when(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01, USER1);
-
-        Collection<FeatureGroupEntity> FGs =
-            vendorLicenseManagerImpl.listFeatureGroups(vlm1_id, VERSION01, USER1);
-
-        verify(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01, USER1);
-        Assert.assertEquals(FGs.size(), 2);
-        FGs.forEach(fg -> Assert.assertTrue(fg.getId().matches(fg1_id + "|" + fg2_id)));
-    }
-
-    @Test
-    public void testCreateFeatureGroup() {
-        FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id,VERSION01,
-            fg1_id);
-
-        doReturn(featureGroupEntity).when(vendorLicenseFacadeMcok).createFeatureGroup
-            (featureGroupEntity,USER1);
+  }
+
+  @Test
+  public void testListFeatureGroups() {
+    doReturn(Arrays.asList(
+        createFeatureGroup(vlm1_id, VERSION01, fg1_id, "FG1", "FG1 desc", new HashSet<String>(),
+            new HashSet<String>()),
+        createFeatureGroup(vlm1_id, VERSION01, fg2_id, "FG2", "FG2 desc", new HashSet<String>(),
+            new HashSet<String>())))
+        .when(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01);
+
+    Collection<FeatureGroupEntity> FGs =
+        vendorLicenseManagerImpl.listFeatureGroups(vlm1_id, VERSION01);
+
+    verify(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01);
+    Assert.assertEquals(FGs.size(), 2);
+    FGs.forEach(fg -> Assert.assertTrue(fg.getId().matches(fg1_id + "|" + fg2_id)));
+  }
 
-        vendorLicenseManagerImpl.createFeatureGroup(featureGroupEntity,USER1);
-
-        verify(vendorLicenseFacadeMcok).createFeatureGroup(featureGroupEntity,USER1);
-    }
-
-
-    @Test
-    public void testUpdateFeatureGroup(){
-        VersionInfo versionInfo = new VersionInfo();
-        versionInfo.setActiveVersion(VERSION01);
-        versionInfo.setLockingUser(USER1);
-        ArrayList<Version> viewable = new ArrayList<Version>();
-        viewable.add(VERSION01);
-        versionInfo.setViewableVersions(viewable);
-
-        doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id,
-            VersionableEntityAction.Write, USER1);
-        FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id);
-
-        existingFG.setEntitlementPoolIds(new HashSet<String>());
-        existingFG.setLicenseKeyGroupIds(new HashSet<String>());
-
-        doReturn(existingFG).when(featureGroupDao).get(existingFG);
-
-        Set<String> removedEPs = new HashSet<>();
-        Set<String> addedEPs = new HashSet<>();
-
-        addedEPs.add(ep1_id);
-        addedEPs.add(ep2_id);
-        EntitlementPoolEntity ep1 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep1_id);
-        EntitlementPoolEntity ep2 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep2_id);
-        doReturn(ep1).when(entitlementPoolDao).get(ep1);
-        doReturn(ep2).when(entitlementPoolDao).get(ep2);
-
-        Set<String> removedLKGs = new HashSet<>();
-        Set<String> addedLKGs = new HashSet<>();
-
-        addedLKGs.add(lkg1_id);
-        addedLKGs.add(lkg2_id);
-        LicenseKeyGroupEntity lkg1 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg1_id);
-        LicenseKeyGroupEntity lkg2 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg2_id);
-        doReturn(lkg1).when(licenseKeyGroupDao).get(lkg1);
-        doReturn(lkg2).when(licenseKeyGroupDao).get(lkg2);
-
-        doNothing().when(vendorLicenseManagerImpl).updateUniqueName(anyObject(), anyObject(),
-            anyObject(),anyObject(), anyObject());
-
-        vendorLicenseManagerImpl.updateFeatureGroup(existingFG,addedLKGs,removedLKGs, addedEPs,
-            removedEPs, USER1);
-
-        verify(vendorLicenseManagerImpl).addLicenseKeyGroupsToFeatureGroupsRef(addedLKGs,
-            existingFG);
-        verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(removedLKGs,
-            existingFG);
-        verify(vendorLicenseManagerImpl).addEntitlementPoolsToFeatureGroupsRef(addedEPs,existingFG);
-        verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(removedEPs,
-            existingFG);
-
-        verify(featureGroupDao)
-            .updateFeatureGroup(existingFG,addedEPs,removedEPs, addedLKGs, removedLKGs);
-        verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01);
-    }
-
-
-    @Test
-    public void testGetFeatureGroup(){
-        FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id,VERSION01,fg1_id);
-        vendorLicenseManagerImpl.getFeatureGroupModel(featureGroupEntity,USER1);
-        verify(vendorLicenseFacadeMcok).getFeatureGroupModel(featureGroupEntity,USER1);
-    }
-
-    @Test
-    public void deleteFeatureGroupTest() {
-
-        VersionInfo versionInfo = new VersionInfo();
-        versionInfo.setActiveVersion(VERSION01);
-        versionInfo.setLockingUser(USER1);
-        ArrayList<Version> viewable = new ArrayList<Version>();
-        viewable.add(VERSION01);
-        versionInfo.setViewableVersions(viewable);
-
-        doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id,
-            VersionableEntityAction.Write, USER1);
-
-        FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id);
-        existingFG.setName("FG_name");
-        existingFG.setLicenseKeyGroupIds(new HashSet<String>());
-        existingFG.setEntitlementPoolIds(new HashSet<String>());
-        existingFG.setLicenseKeyGroupIds(new HashSet<String>());
-
-        doReturn(existingFG).when(featureGroupDao).get(anyObject());
-
-        doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants
-            .UniqueValues.FEATURE_GROUP_NAME,vlm1_id,VERSION01.toString(),existingFG.getName());
-
-        vendorLicenseManagerImpl.deleteFeatureGroup(existingFG, USER1);
-
-        verify(featureGroupDao).delete(existingFG);
-        verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01);
-
-        verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(existingFG
-            .getLicenseKeyGroupIds(),existingFG);
-        verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(existingFG
-            .getEntitlementPoolIds(),existingFG);
-        verify(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants
-            .UniqueValues.FEATURE_GROUP_NAME,vlm1_id,VERSION01.toString(),existingFG.getName());
-    }
-
-    private FeatureGroupEntity createFeatureGroup(String vendorId, Version version, String id,
-                                                  String name, String description,
-                                                  Set<String> entitlementPoolIds,
-                                                  Set<String> licenseKeyGroupIds) {
-        FeatureGroupEntity featureGroup = new FeatureGroupEntity();
-        featureGroup.setVendorLicenseModelId(vendorId);
-        featureGroup.setVersion(version);
-        featureGroup.setId(id);
-        featureGroup.setName(name);
-        featureGroup.setDescription(description);
-        featureGroup.setEntitlementPoolIds(entitlementPoolIds);
-        featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
-        return featureGroup;
-    }
+  @Test
+  public void testCreateFeatureGroup() {
+    FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id, VERSION01,
+        fg1_id);
+
+    doReturn(featureGroupEntity).when(vendorLicenseFacadeMcok).createFeatureGroup
+        (featureGroupEntity);
+
+    vendorLicenseManagerImpl.createFeatureGroup(featureGroupEntity);
+
+    verify(vendorLicenseFacadeMcok).createFeatureGroup(featureGroupEntity);
+  }
+
+
+  @Test
+  public void testUpdateFeatureGroup() {
+    FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id);
+
+    existingFG.setEntitlementPoolIds(new HashSet<String>());
+    existingFG.setLicenseKeyGroupIds(new HashSet<String>());
+
+    doReturn(existingFG).when(featureGroupDao).get(existingFG);
+
+    Set<String> removedEPs = new HashSet<>();
+    Set<String> addedEPs = new HashSet<>();
+
+    addedEPs.add(ep1_id);
+    addedEPs.add(ep2_id);
+    EntitlementPoolEntity ep1 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep1_id);
+    EntitlementPoolEntity ep2 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep2_id);
+    doReturn(ep1).when(entitlementPoolDao).get(ep1);
+    doReturn(ep2).when(entitlementPoolDao).get(ep2);
+
+    Set<String> removedLKGs = new HashSet<>();
+    Set<String> addedLKGs = new HashSet<>();
+
+    addedLKGs.add(lkg1_id);
+    addedLKGs.add(lkg2_id);
+    LicenseKeyGroupEntity lkg1 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg1_id);
+    LicenseKeyGroupEntity lkg2 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg2_id);
+    doReturn(lkg1).when(licenseKeyGroupDao).get(lkg1);
+    doReturn(lkg2).when(licenseKeyGroupDao).get(lkg2);
+
+    doNothing().when(vendorLicenseManagerImpl).updateUniqueName(anyObject(), anyObject(),
+        anyObject(), anyObject(), anyObject());
+
+    vendorLicenseManagerImpl.updateFeatureGroup(existingFG, addedLKGs, removedLKGs, addedEPs,
+        removedEPs);
+
+    verify(vendorLicenseManagerImpl).addLicenseKeyGroupsToFeatureGroupsRef(addedLKGs,
+        existingFG);
+    verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(removedLKGs,
+        existingFG);
+    verify(vendorLicenseManagerImpl).addEntitlementPoolsToFeatureGroupsRef(addedEPs, existingFG);
+    verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(removedEPs,
+        existingFG);
+
+    verify(featureGroupDao)
+        .updateFeatureGroup(existingFG, addedEPs, removedEPs, addedLKGs, removedLKGs);
+  }
+
+
+  @Test
+  public void testGetFeatureGroup() {
+    FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id);
+    vendorLicenseManagerImpl.getFeatureGroupModel(featureGroupEntity);
+    verify(vendorLicenseFacadeMcok).getFeatureGroupModel(featureGroupEntity);
+  }
+
+  @Test
+  public void deleteFeatureGroupTest() {
+
+    FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id);
+    existingFG.setName("FG_name");
+    existingFG.setLicenseKeyGroupIds(new HashSet<String>());
+    existingFG.setEntitlementPoolIds(new HashSet<String>());
+    existingFG.setLicenseKeyGroupIds(new HashSet<String>());
+
+    doReturn(existingFG).when(featureGroupDao).get(anyObject());
+
+    doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants
+        .UniqueValues.FEATURE_GROUP_NAME, vlm1_id, VERSION01.toString(), existingFG.getName());
+
+    vendorLicenseManagerImpl.deleteFeatureGroup(existingFG);
+
+    verify(featureGroupDao).delete(existingFG);
+
+    verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(existingFG
+        .getLicenseKeyGroupIds(), existingFG);
+    verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(existingFG
+        .getEntitlementPoolIds(), existingFG);
+    verify(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants
+        .UniqueValues.FEATURE_GROUP_NAME, vlm1_id, VERSION01.toString(), existingFG.getName());
+  }
+
+  private FeatureGroupEntity createFeatureGroup(String vendorId, Version version, String id,
+                                                String name, String description,
+                                                Set<String> entitlementPoolIds,
+                                                Set<String> licenseKeyGroupIds) {
+    FeatureGroupEntity featureGroup = new FeatureGroupEntity();
+    featureGroup.setVendorLicenseModelId(vendorId);
+    featureGroup.setVersion(version);
+    featureGroup.setId(id);
+    featureGroup.setName(name);
+    featureGroup.setDescription(description);
+    featureGroup.setEntitlementPoolIds(entitlementPoolIds);
+    featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
+    return featureGroup;
+  }
 }
 
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java
index b0b5953a53..91435e85fd 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java
@@ -26,17 +26,11 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
-import org.openecomp.core.util.UniqueValueUtil;
-import org.openecomp.core.utilities.CommonMethods;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
-import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
 import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao;
-import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDaoFactory;
 import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao;
-import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDaoFactory;
 import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
 import org.openecomp.sdc.vendorlicense.dao.LimitDao;
 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
@@ -44,36 +38,24 @@ import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther;
 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
 import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm;
-import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
-import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
 import org.openecomp.sdc.versioning.VersioningManager;
-import org.openecomp.sdc.versioning.VersioningUtil;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
 import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.verify;
-import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE;
-import static org.testng.AssertJUnit.assertEquals;
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
 public class LicenseAgreementTest {
 
   private static final String USER1 = "TestUser1";
@@ -104,8 +86,6 @@ public class LicenseAgreementTest {
   private LicenseKeyGroupDao licenseKeyGroupDaoMcok;
   @Mock
   private LimitDao limitDaoMcok;
-  @Mock
-  private ActivityLogManager activityLogManagerMcok;
 
 
   @Spy
@@ -160,12 +140,12 @@ public class LicenseAgreementTest {
   @Test
   public void listLicenseAgreementsTest() {
 
-    LicenseAgreementEntity la = new LicenseAgreementEntity(vlm1_id,VERSION01,USER1);
-    doReturn(la).when(vendorLicenseManager).createLicenseAgreementForList(vlm1_id,VERSION01, USER1);
+    LicenseAgreementEntity la =
+        new LicenseAgreementEntity(vlm1_id, VERSION01, null); // TODO: 8/13/2017
 
     doReturn(Arrays.asList(
         createLicenseAgreement(vlm1_id, VERSION01, la1_id, "LA1", "LA1 " +
-                "desc","RequirementsAndConstrains2", new ChoiceOrOther<>(LicenseTerm.Unlimited, null),
+                "desc", "RequirementsAndConstrains2", new ChoiceOrOther<>(LicenseTerm.Unlimited, null),
             "fg1"),
         createLicenseAgreement(vlm1_id, VERSION01, la2_id, "LA2", "LA2 desc",
             "RequirementsAndConstrains2", new ChoiceOrOther<>(LicenseTerm.Unlimited, null),
@@ -173,23 +153,23 @@ public class LicenseAgreementTest {
         .when(licenseAgreementDaoMcok).list(la);
 
     Collection<LicenseAgreementEntity> LAs =
-        vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01, USER1);
+        vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01);
     Assert.assertEquals(LAs.size(), 2);
-    LAs.forEach(licseAgreement-> Assert.assertTrue(licseAgreement.getId().matches(la1_id + "|" + la2_id)));
+    LAs.forEach(
+        licseAgreement -> Assert.assertTrue(licseAgreement.getId().matches(la1_id + "|" + la2_id)));
   }
 
   @Test
   public void testListLicenseAgreementsWhenNone() {
 
-    LicenseAgreementEntity la = new LicenseAgreementEntity(vlm1_id,VERSION01,USER1);
-    doReturn(la).when(vendorLicenseManager).createLicenseAgreementForList(vlm1_id,VERSION01,
-        USER1);
+    LicenseAgreementEntity la =
+        new LicenseAgreementEntity(vlm1_id, VERSION01, null); // TODO: 8/13/2017
 
     doReturn(new ArrayList<LicenseAgreementEntity>())
         .when(licenseAgreementDaoMcok).list(la);
 
     Collection<LicenseAgreementEntity> LAs =
-        vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01, USER1);
+        vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01);
 
     verify(licenseAgreementDaoMcok).list(la);
     Assert.assertEquals(LAs.size(), 0);
@@ -199,29 +179,19 @@ public class LicenseAgreementTest {
   @Test
   public void testCreateLicenseAgreement() {
 
-    LicenseAgreementEntity licenseAgreementEntity = new LicenseAgreementEntity(vlm1_id,VERSION01,
+    LicenseAgreementEntity licenseAgreementEntity = new LicenseAgreementEntity(vlm1_id, VERSION01,
         la2_id);
 
     doReturn(licenseAgreementEntity).when(vendorLicenseFacadeMcok).createLicenseAgreement
-        (licenseAgreementEntity,USER1);
+        (licenseAgreementEntity);
 
-    vendorLicenseManager.createLicenseAgreement(licenseAgreementEntity,USER1);
+    vendorLicenseManager.createLicenseAgreement(licenseAgreementEntity);
 
-    verify(vendorLicenseFacadeMcok).createLicenseAgreement(licenseAgreementEntity,USER1);
+    verify(vendorLicenseFacadeMcok).createLicenseAgreement(licenseAgreementEntity);
   }
 
   @Test
   public void testUpdateLicenseAgreement() {
-
-    VersionInfo versionInfo = new VersionInfo();
-    versionInfo.setActiveVersion(VERSION01);
-    versionInfo.setLockingUser(USER1);
-    ArrayList<Version> viewable = new ArrayList<Version>();
-    viewable.add(VERSION01);
-    versionInfo.setViewableVersions(viewable);
-
-    doReturn(versionInfo).when(vendorLicenseManager).getVersionInfo(vlm1_id,
-        VersionableEntityAction.Write, USER1);
     LicenseAgreementEntity existingLA = new LicenseAgreementEntity(vlm1_id, VERSION01, la1_id);
 
     existingLA.setFeatureGroupIds(new HashSet<String>());
@@ -236,34 +206,20 @@ public class LicenseAgreementTest {
     FeatureGroupEntity fg2 = new FeatureGroupEntity(vlm1_id, VERSION01, fg2_id);
     doReturn(fg1).when(featureGroupDaoMcok).get(fg1);
     doReturn(fg2).when(featureGroupDaoMcok).get(fg2);
-    doReturn(existingLA).when(vendorLicenseManager).createLicenseAgreementForList(vlm1_id,VERSION01,
-        USER1);
     doNothing().when(vendorLicenseManager).updateUniqueName(anyObject(), anyObject(), anyObject(),
         anyObject(), anyObject());
 
-    vendorLicenseManager.updateLicenseAgreement(existingLA, addedFGs, removedFGs, USER1);
+    vendorLicenseManager.updateLicenseAgreement(existingLA, addedFGs, removedFGs);
 
     verify(licenseAgreementDaoMcok)
         .updateColumnsAndDeltaFeatureGroupIds(existingLA, addedFGs, removedFGs);
-    verify(vendorLicenseManager).addFeatureGroupsToLicenseAgreementRef(addedFGs,existingLA);
-    verify(vendorLicenseManager).removeFeatureGroupsToLicenseAgreementRef(removedFGs,existingLA);
-    verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01);
+    verify(vendorLicenseManager).addFeatureGroupsToLicenseAgreementRef(addedFGs, existingLA);
+    verify(vendorLicenseManager).removeFeatureGroupsToLicenseAgreementRef(removedFGs, existingLA);
 
   }
 
   @Test
   public void deleteLicenseAgreementsTest() {
-
-    VersionInfo versionInfo = new VersionInfo();
-    versionInfo.setActiveVersion(VERSION01);
-    versionInfo.setLockingUser(USER1);
-    ArrayList<Version> viewable = new ArrayList<Version>();
-    viewable.add(VERSION01);
-    versionInfo.setViewableVersions(viewable);
-
-    doReturn(versionInfo).when(vendorLicenseManager).getVersionInfo(vlm1_id,
-        VersionableEntityAction.Write, USER1);
-
     LicenseAgreementEntity existingLA = new LicenseAgreementEntity(vlm1_id, VERSION01, la1_id);
     existingLA.setName("LA");
     existingLA.setFeatureGroupIds(new HashSet<>());
@@ -271,20 +227,19 @@ public class LicenseAgreementTest {
     doReturn(existingLA).when(licenseAgreementDaoMcok).get(anyObject());
 
     doNothing().when(vendorLicenseManager).deleteUniqueName(VendorLicenseConstants.UniqueValues
-        .LICENSE_AGREEMENT_NAME,vlm1_id,VERSION01.toString(),existingLA.getName());
+        .LICENSE_AGREEMENT_NAME, vlm1_id, VERSION01.toString(), existingLA.getName());
 
-    vendorLicenseManager.deleteLicenseAgreement(vlm1_id, VERSION01, la1_id, USER1);
+    vendorLicenseManager.deleteLicenseAgreement(vlm1_id, VERSION01, la1_id);
 
     verify(licenseAgreementDaoMcok).delete(existingLA);
-    verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01);
     verify(vendorLicenseManager).removeFeatureGroupsToLicenseAgreementRef(existingLA
-        .getFeatureGroupIds(),existingLA);
+        .getFeatureGroupIds(), existingLA);
   }
 
   @Test
-  public void testGetLicenseAgreement(){
-    vendorLicenseManager.getLicenseAgreementModel(vlm1_id,VERSION01,la1_id,USER1);
-    verify(vendorLicenseFacadeMcok).getLicenseAgreementModel(vlm1_id,VERSION01,la1_id,USER1);
+  public void testGetLicenseAgreement() {
+    vendorLicenseManager.getLicenseAgreementModel(vlm1_id, VERSION01, la1_id);
+    verify(vendorLicenseFacadeMcok).getLicenseAgreementModel(vlm1_id, VERSION01, la1_id);
   }
 
 /*
@@ -300,7 +255,7 @@ public class LicenseAgreementTest {
     featureGroupDao.create(created);
     featureGroupDao.addReferencingLicenseAgreement(created, licenseAgreement.getId());
 
-    vendorLicenseManager.deleteFeatureGroup(created, USER1);
+    vendorLicenseManager.deleteFeatureGroup(created);
     LicenseAgreementEntity afterDeletingFG = licenseAgreementDao.get(licenseAgreement);
     Assert.assertEquals(afterDeletingFG.getFeatureGroupIds().size(), 1);
     Assert.assertTrue(afterDeletingFG.getFeatureGroupIds().contains("fg2"));
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java
index f0dd383a1f..dc376ee5b6 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java
@@ -26,21 +26,19 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
 import org.openecomp.sdc.vendorlicense.dao.LimitDao;
-import org.openecomp.sdc.vendorlicense.dao.types.*;
+import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType;
+import org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther;
+import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope;
 import org.openecomp.sdc.vendorlicense.errors.VendorLicenseErrorCodes;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.Arrays;
@@ -56,10 +54,10 @@ import static org.mockito.Mockito.verify;
 public class LicenseKeyGroupTest {
 
   //JUnit Test Cases using Mockito
-  private  final String USER = "lkgTestUser";
-  private  final String LKG_NAME = "LKG name";
-  private  final String LKG2_NAME = "LKG2 name";
-  private  final String LT_NAME = "LT name";
+  private final String USER = "lkgTestUser";
+  private final String LKG_NAME = "LKG name";
+  private final String LKG2_NAME = "LKG2 name";
+  private final String LT_NAME = "LT name";
   private final String LKG1_NAME = "LKG1 name";
   private final String USER1 = "user1";
   private static String lkg1_id = "lkg1_id";
@@ -85,15 +83,16 @@ public class LicenseKeyGroupTest {
     MockitoAnnotations.initMocks(this);
   }
 
-  private LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyType type, Set<OperationalScope> operationalScopeChoices,
-                                                      String operationalScopeOther)
-  {
+  private LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyType type,
+                                                      Set<OperationalScope> operationalScopeChoices,
+                                                      String operationalScopeOther) {
     LicenseKeyGroupEntity licenseKeyGroupEntity = new LicenseKeyGroupEntity();
     licenseKeyGroupEntity.setType(type);
     licenseKeyGroupEntity.setOperationalScope(
         new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther));
     return licenseKeyGroupEntity;
   }
+
   /*
       @Test
       public void deleteLicenseKeyGroupTest() {
@@ -207,14 +206,14 @@ public class LicenseKeyGroupTest {
     opScopeChoices.add(OperationalScope.CPU);
     opScopeChoices.add(OperationalScope.Network_Wide);
     LicenseKeyGroupEntity lkg =
-        createLicenseKeyGroup("vlm1Id", null,lkg1_id, LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+        createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", LicenseKeyType.Unique,
             new MultiChoiceOrOther<>(opScopeChoices, null));
     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
     lkg.setStartDate(LocalDate.now().format(formatter));
     lkg.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
 
-    vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1);
-    verify(vendorLicenseFacade).createLicenseKeyGroup(lkg,USER1);
+    vendorLicenseManagerImpl.createLicenseKeyGroup(lkg);
+    verify(vendorLicenseFacade).createLicenseKeyGroup(lkg);
   }
 
   @Test
@@ -227,12 +226,13 @@ public class LicenseKeyGroupTest {
       opScopeChoices.add(OperationalScope.CPU);
       opScopeChoices.add(OperationalScope.Network_Wide);
       LicenseKeyGroupEntity lkg =
-          createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+          createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec",
+              LicenseKeyType.Unique,
               new MultiChoiceOrOther<>(opScopeChoices, null));
       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
       lkg.setStartDate(LocalDate.now().format(formatter));
       lkg.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
-      vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1);
+      vendorLicenseManagerImpl.createLicenseKeyGroup(lkg);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
@@ -249,11 +249,12 @@ public class LicenseKeyGroupTest {
       opScopeChoices.add(OperationalScope.CPU);
       opScopeChoices.add(OperationalScope.Network_Wide);
       LicenseKeyGroupEntity lkg =
-          createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+          createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec",
+              LicenseKeyType.Unique,
               new MultiChoiceOrOther<>(opScopeChoices, null));
       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
       lkg.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
-      vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1).getId();
+      vendorLicenseManagerImpl.createLicenseKeyGroup(lkg).getId();
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
@@ -270,12 +271,13 @@ public class LicenseKeyGroupTest {
       opScopeChoices.add(OperationalScope.CPU);
       opScopeChoices.add(OperationalScope.Network_Wide);
       LicenseKeyGroupEntity lkg =
-          createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+          createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec",
+              LicenseKeyType.Unique,
               new MultiChoiceOrOther<>(opScopeChoices, null));
       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
       lkg.setStartDate(LocalDate.now().plusDays(2L).format(formatter));
       lkg.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
-      vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1).getId();
+      vendorLicenseManagerImpl.createLicenseKeyGroup(lkg).getId();
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
@@ -290,19 +292,14 @@ public class LicenseKeyGroupTest {
     opScopeChoices.add(OperationalScope.CPU);
     opScopeChoices.add(OperationalScope.Network_Wide);
     LicenseKeyGroupEntity lkg =
-        createLicenseKeyGroup(vlm1_id, null,lkg1_id, LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+        createLicenseKeyGroup(vlm1_id, null, lkg1_id, LKG1_NAME, "LKG1 dec", LicenseKeyType.Unique,
             new MultiChoiceOrOther<>(opScopeChoices, null));
     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
     lkg.setStartDate(LocalDate.now().minusDays(3L).format(formatter));
     lkg.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
-    VersionInfo info = new VersionInfo();
-    info.getViewableVersions().add(VERSION01);
-    info.setActiveVersion(VERSION01);
-    doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
-
-    vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1);
-    verify(vendorLicenseFacade).updateLicenseKeyGroup(lkg,USER1);
-    verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01);
+
+    vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg);
+    verify(vendorLicenseFacade).updateLicenseKeyGroup(lkg);
   }
 
   @Test
@@ -315,12 +312,13 @@ public class LicenseKeyGroupTest {
       opScopeChoices.add(OperationalScope.CPU);
       opScopeChoices.add(OperationalScope.Network_Wide);
       LicenseKeyGroupEntity lkg =
-          createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+          createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec",
+              LicenseKeyType.Unique,
               new MultiChoiceOrOther<>(opScopeChoices, null));
       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
       lkg.setStartDate(LocalDate.now().format(formatter));
       lkg.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
-      vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1);
+      vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
@@ -337,11 +335,12 @@ public class LicenseKeyGroupTest {
       opScopeChoices.add(OperationalScope.CPU);
       opScopeChoices.add(OperationalScope.Network_Wide);
       LicenseKeyGroupEntity lkg =
-          createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+          createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec",
+              LicenseKeyType.Unique,
               new MultiChoiceOrOther<>(opScopeChoices, null));
       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
       lkg.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
-      vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1);
+      vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
@@ -358,12 +357,13 @@ public class LicenseKeyGroupTest {
       opScopeChoices.add(OperationalScope.CPU);
       opScopeChoices.add(OperationalScope.Network_Wide);
       LicenseKeyGroupEntity lkg =
-          createLicenseKeyGroup("vlm1Id", null,lkg1_id, LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique,
+          createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec",
+              LicenseKeyType.Unique,
               new MultiChoiceOrOther<>(opScopeChoices, null));
       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
       lkg.setStartDate(LocalDate.now().format(formatter));
       lkg.setExpiryDate(LocalDate.now().format(formatter));
-      vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1);
+      vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
@@ -371,9 +371,10 @@ public class LicenseKeyGroupTest {
   }
 
   @Test
-  public void testListlistLicenseKeyGroups(){
+  public void testListlistLicenseKeyGroups() {
 
-    MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = new MultiChoiceOrOther<OperationalScope>();
+    MultiChoiceOrOther<OperationalScope> multiChoiceOrOther =
+        new MultiChoiceOrOther<OperationalScope>();
     Set<OperationalScope> opScopeChoices = new HashSet<>();
     opScopeChoices.add(OperationalScope.Core);
     opScopeChoices.add(OperationalScope.CPU);
@@ -382,34 +383,25 @@ public class LicenseKeyGroupTest {
     multiChoiceOrOther.setOther("Other");
 
     doReturn(Arrays.asList(
-        createLicenseKeyGroup(vlm1_id,VERSION01, lkg1_id, LKG1_NAME,"LKG1 dec", LicenseKeyType.Universal,
+        createLicenseKeyGroup(vlm1_id, VERSION01, lkg1_id, LKG1_NAME, "LKG1 dec",
+            LicenseKeyType.Universal,
             multiChoiceOrOther),
-        createLicenseKeyGroup(vlm1_id,VERSION01, lkg2_id, LKG2_NAME,"LKG2 dec", LicenseKeyType
+        createLicenseKeyGroup(vlm1_id, VERSION01, lkg2_id, LKG2_NAME, "LKG2 dec", LicenseKeyType
             .Universal, multiChoiceOrOther)))
-        .when(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01, USER1);
+        .when(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01);
 
     Collection<LicenseKeyGroupEntity> LKGs =
-        vendorLicenseManagerImpl.listLicenseKeyGroups(vlm1_id, VERSION01, USER1);
+        vendorLicenseManagerImpl.listLicenseKeyGroups(vlm1_id, VERSION01);
 
-    verify(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01, USER1);
+    verify(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01);
     Assert.assertEquals(LKGs.size(), 2);
     LKGs.forEach(lkg -> Assert.assertTrue(lkg.getId().matches(lkg1_id + "|" + lkg2_id)));
   }
 
   @Test
-  public void testGetLicenseKeyGroup(){
-    VersionInfo versionInfo = new VersionInfo();
-    versionInfo.setActiveVersion(VERSION01);
-    versionInfo.setLockingUser(USER1);
-    ArrayList<Version> viewable = new ArrayList<Version>();
-    viewable.add(VERSION01);
-    versionInfo.setViewableVersions(viewable);
-    versionInfo.setActiveVersion(VERSION01);
-
-    doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id,
-        VersionableEntityAction.Read, USER1);
-
-    MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = new MultiChoiceOrOther<OperationalScope>();
+  public void testGetLicenseKeyGroup() {
+    MultiChoiceOrOther<OperationalScope> multiChoiceOrOther =
+        new MultiChoiceOrOther<OperationalScope>();
     Set<OperationalScope> opScopeChoices = new HashSet<>();
     opScopeChoices.add(OperationalScope.Core);
     opScopeChoices.add(OperationalScope.CPU);
@@ -417,35 +409,24 @@ public class LicenseKeyGroupTest {
     multiChoiceOrOther.setChoices(opScopeChoices);
     multiChoiceOrOther.setOther("Other");
 
-    LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id,VERSION01, lkg1_id, LKG1_NAME,
+    LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id, VERSION01, lkg1_id, LKG1_NAME,
         "LKG1 dec", LicenseKeyType.Universal, multiChoiceOrOther);
 
     doReturn(lkg).when(licenseKeyGroupDao).get(anyObject());
 
-    LicenseKeyGroupEntity lkgRetrived = vendorLicenseManagerImpl.getLicenseKeyGroup(lkg,USER1);
+    LicenseKeyGroupEntity lkgRetrived = vendorLicenseManagerImpl.getLicenseKeyGroup(lkg);
     verify(licenseKeyGroupDao).get(lkg);
 
-    Assert.assertEquals(lkgRetrived.getId(),lkg.getId());
-    Assert.assertEquals(lkgRetrived.getVendorLicenseModelId(),lkg.getVendorLicenseModelId());
-    Assert.assertEquals(lkgRetrived.getVersion(),lkg.getVersion());
+    Assert.assertEquals(lkgRetrived.getId(), lkg.getId());
+    Assert.assertEquals(lkgRetrived.getVendorLicenseModelId(), lkg.getVendorLicenseModelId());
+    Assert.assertEquals(lkgRetrived.getVersion(), lkg.getVersion());
 
   }
 
   @Test
   public void testDeleteLicenseKeyGroup() {
-
-    VersionInfo versionInfo = new VersionInfo();
-    versionInfo.setActiveVersion(VERSION01);
-    versionInfo.setLockingUser(USER1);
-    ArrayList<Version> viewable = new ArrayList<Version>();
-    viewable.add(VERSION01);
-    versionInfo.setViewableVersions(viewable);
-
-    doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id,
-        VersionableEntityAction.Write, USER1);
-
-
-    MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = new MultiChoiceOrOther<OperationalScope>();
+    MultiChoiceOrOther<OperationalScope> multiChoiceOrOther =
+        new MultiChoiceOrOther<OperationalScope>();
     Set<OperationalScope> opScopeChoices = new HashSet<>();
     opScopeChoices.add(OperationalScope.Core);
     opScopeChoices.add(OperationalScope.CPU);
@@ -453,26 +434,26 @@ public class LicenseKeyGroupTest {
     multiChoiceOrOther.setChoices(opScopeChoices);
     multiChoiceOrOther.setOther("Other");
 
-    LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id,VERSION01, lkg1_id, LKG1_NAME,
+    LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id, VERSION01, lkg1_id, LKG1_NAME,
         "LKG1 dec", LicenseKeyType.Universal, multiChoiceOrOther);
 
     lkg.setReferencingFeatureGroups(new HashSet<>());
 
     doReturn(lkg).when(licenseKeyGroupDao).get(anyObject());
 
-    doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id,VERSION01,lkg1_id,USER1);
+    doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id, VERSION01, lkg1_id);
 
-    doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(),anyObject(),
-        anyObject(),anyObject());
+    doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(), anyObject(),
+        anyObject(), anyObject());
 
-    vendorLicenseManagerImpl.deleteLicenseKeyGroup(lkg, USER1);
+    vendorLicenseManagerImpl.deleteLicenseKeyGroup(lkg);
 
     verify(licenseKeyGroupDao).delete(lkg);
-    verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01);
 
   }
 
-  public static LicenseKeyGroupEntity createLicenseKeyGroup(String vlmId, Version version,String id,
+  public static LicenseKeyGroupEntity createLicenseKeyGroup(String vlmId, Version version,
+                                                            String id,
                                                             String name, String desc,
                                                             LicenseKeyType type,
                                                             MultiChoiceOrOther<OperationalScope> operationalScope) {
@@ -525,7 +506,7 @@ public class LicenseKeyGroupTest {
 
     vlm1Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest
         .createVendorLicenseModel("vendor1 name " + CommonMethods.nextUuId(), "vlm1Id dec",
-            "icon1"), USER1).getId();
+            "icon1")1).getId();
     vlm2Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest
             .createVendorLicenseModel("vendor2 name " + CommonMethods.nextUuId(), "vlm2 dec", "icon2"),
         USER1).getId();
@@ -545,7 +526,7 @@ public class LicenseKeyGroupTest {
     LicenseKeyGroupEntity
         lkg1 = createLicenseKeyGroup(vlmId, VERSION01, name, "LKG1 dec", LicenseKeyType.One_Time,
         new MultiChoiceOrOther<>(opScopeChoices, null));
-    String lkg1Id = vendorLicenseManager.createLicenseKeyGroup(lkg1, USER1).getId();
+    String lkg1Id = vendorLicenseManager.createLicenseKeyGroup(lkg11).getId();
     lkg1.setId(lkg1Id);
 
     LicenseKeyGroupEntity loadedLkg1 = licenseKeyGroupDao.get(lkg1);
@@ -560,7 +541,7 @@ public class LicenseKeyGroupTest {
           createLicenseKeyGroup(vlm1Id, VERSION01, LKG1_NAME, "LKG1 dec", LicenseKeyType.One_Time,
               new MultiChoiceOrOther<>(Collections.singleton(OperationalScope.Other),
                   "other op scope"));
-      vendorLicenseManager.createLicenseKeyGroup(lkg1, USER1).getId();
+      vendorLicenseManager.createLicenseKeyGroup(lkg11).getId();
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
@@ -581,9 +562,9 @@ public class LicenseKeyGroupTest {
     lkg1.setOperationalScope(new MultiChoiceOrOther<>(opScopeChoices, "op scope1 updated"));
     lkg1.setDescription("LKG1 dec updated");
 
-    vendorLicenseManager.updateLicenseKeyGroup(lkg1, USER1);
+    vendorLicenseManager.updateLicenseKeyGroup(lkg11);
 
-    LicenseKeyGroupEntity loadedLkg1 = vendorLicenseManager.getLicenseKeyGroup(lkg1, USER1);
+    LicenseKeyGroupEntity loadedLkg1 = vendorLicenseManager.getLicenseKeyGroup(lkg11);
     Assert.assertTrue(loadedLkg1.equals(lkg1));
 
   }
@@ -595,11 +576,11 @@ public class LicenseKeyGroupTest {
     LicenseKeyGroupEntity lkg2 =
         createLicenseKeyGroup(vlm1Id, VERSION01, "LKG2", "LKG2 dec", LicenseKeyType.Universal,
             new MultiChoiceOrOther<>(opScopeChoices, null));
-    lkg2Id = vendorLicenseManager.createLicenseKeyGroup(lkg2, USER1).getId();
+    lkg2Id = vendorLicenseManager.createLicenseKeyGroup(lkg21).getId();
     lkg2.setId(lkg2Id);
 
     Collection<LicenseKeyGroupEntity> loadedLkgs =
-        vendorLicenseManager.listLicenseKeyGroups(vlm1Id, null, USER1);
+        vendorLicenseManager.listLicenseKeyGroups(vlm1Id, null1);
     Assert.assertEquals(loadedLkgs.size(), 2);
     for (LicenseKeyGroupEntity loadedLkg : loadedLkgs) {
       if (lkg2Id.equals(loadedLkg.getId())) {
@@ -611,7 +592,7 @@ public class LicenseKeyGroupTest {
   @Test(dependsOnMethods = {"listTest"})
   public void deleteTest() {
     vendorLicenseManager
-        .deleteLicenseKeyGroup(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id), USER1);
+        .deleteLicenseKeyGroup(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id)1);
 
     LicenseKeyGroupEntity loadedLkg1 =
         licenseKeyGroupDao.get(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id));
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java
index 195fa5d4da..d1df147a60 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java
@@ -1,12 +1,12 @@
 package org.openecomp.sdc.vendorlicense.impl;
 
-import org.junit.rules.ExpectedException;
-import org.openecomp.core.util.UniqueValueUtil;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.common.errors.ErrorCategory;
-import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
 import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
 import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao;
@@ -14,50 +14,17 @@ import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao;
 import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
 import org.openecomp.sdc.vendorlicense.dao.LimitDao;
 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
-import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther;
-import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm;
 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
-import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
-import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
-import org.openecomp.sdc.vendorsoftwareproduct.types.VersionedVendorSoftwareProductInfo;
 import org.openecomp.sdc.versioning.VersioningManager;
-import org.openecomp.sdc.versioning.VersioningUtil;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.dao.types.VersionStatus;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
-import org.testng.annotations.BeforeMethod;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
 import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.verify;
-import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE;
 
 
 /**
@@ -93,9 +60,6 @@ public class VendorLicenseModelTest {
   private LicenseKeyGroupDao licenseKeyGroupDaoMcok;
   @Mock
   private LimitDao limitDaoMcok;
-  @Mock
-  private ActivityLogManager activityLogManagerMcok;
-
 
   @Spy
   @InjectMocks
@@ -112,159 +76,19 @@ public class VendorLicenseModelTest {
   }
 
   @Test
-  public void testCheckout() {
-
-    doReturn(VERSION01).when(versioningManagerMcok)
-        .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1_id, USER1);
-
-    vendorLicenseManager.checkout(vlm1_id, USER1);
-
-    Assert.assertEquals(VERSION01.getStatus(), VersionStatus.Locked);
-    verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id, VERSION01);
-
-    verify(versioningManagerMcok)
-        .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1_id, USER1);
-
-    verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION01.getMajor() + 1));
-    Assert.assertTrue(activityLogEntity.isSuccess());
-  }
-
-  @Test
-  public void testUndoCheckout() {
-    Version existingVersion = new Version(0, 2);
-    doReturn(existingVersion).when(versioningManagerMcok).undoCheckout(
-        VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1_id, USER1);
-
-    vendorLicenseManager.undoCheckout(vlm1_id, USER1);
-
-    verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id, existingVersion);
-  }
-
-  @Test
-  public void testCheckin() {
-
-    doReturn(VERSION10).when(vendorLicenseFacadeMcok).checkin(vlm1_id, USER1);
-
-    vendorLicenseManager.checkin(vlm1_id, USER1);
-    verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION10.getMajor() + 1));
-    verify(vendorLicenseFacadeMcok).checkin(vlm1_id, USER1);
-
-  }
-
-  @Test
-  public void testSubmit() {
-
-    doReturn(VERSION10).when(vendorLicenseFacadeMcok).submit(vlm1_id, USER1);
-
-    vendorLicenseManager.submit(vlm1_id, USER1);
-    verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION10.getMajor()));
-    verify(vendorLicenseFacadeMcok).submit(vlm1_id, USER1);
-
-  }
-
-  @Test
-  public void testListWhenNone() {
-    doReturn(new HashMap<>()).when(versioningManagerMcok).listEntitiesVersionInfo
-        (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read);
-    Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels
-        (null, USER1);
-    Assert.assertEquals(vlms.size(), 0);
-  }
-
-  @Test
-  public void testList() {
-
-    Map<String, VersionInfo> vlmsTobeReturned = new HashMap<>();
-
-    VersionInfo versionInfo1 = new VersionInfo();
-    versionInfo1.setActiveVersion(VERSION01);
-    vlmsTobeReturned.put(vlm1_id, versionInfo1);
-
-    VersionInfo versionInfo2 = new VersionInfo();
-    versionInfo2.setActiveVersion(VERSION10);
-    vlmsTobeReturned.put(vlm2_id, versionInfo2);
-
-    doReturn(vlmsTobeReturned).when(versioningManagerMcok).listEntitiesVersionInfo
-        (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read);
-
-    VendorLicenseModelEntity vlm1 = new VendorLicenseModelEntity(vlm1_id, VERSION01);
-    vlm1.setWritetimeMicroSeconds(8L);
-    doReturn(vlm1).when(vendorLicenseModelDaoMcok).get(any(VendorLicenseModelEntity.class));
-
-    Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels
-        (null, USER1);
-    Assert.assertEquals(vlms.size(), 2);
-  }
-
-  @Test
-  public void testListFinalsWhenNone() {
-
-    Map<String, VersionInfo> vspsTobeReturned = new HashMap<>();
-
-    VersionInfo versionInfo1 = new VersionInfo();
-    versionInfo1.setActiveVersion(VERSION01);
-    vspsTobeReturned.put(vlm1_id, versionInfo1);
-
-    VersionInfo versionInfo2 = new VersionInfo();
-    versionInfo2.setActiveVersion(VERSION10);
-    vspsTobeReturned.put(vlm2_id, versionInfo2);
-
-    doReturn(vspsTobeReturned).when(versioningManagerMcok).listEntitiesVersionInfo
-        (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read);
-
-    Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels
-        (VersionStatus.Final.name(), USER1);
-    Assert.assertEquals(vlms.size(), 0);
-  }
-
-  @Test
-  public void testListFinals() {
-    Map<String, VersionInfo> vlmsTobeReturned = new HashMap<>();
-
-    VersionInfo versionInfo1 = new VersionInfo();
-    versionInfo1.setActiveVersion(VERSION01);
-    vlmsTobeReturned.put(vlm1_id, versionInfo1);
-
-    VersionInfo versionInfo2 = new VersionInfo();
-
-    versionInfo2.setActiveVersion(new Version(1, 3));
-    versionInfo2.setLatestFinalVersion(VERSION10);
-    vlmsTobeReturned.put(vlm2_id, versionInfo2);
-
-    doReturn(vlmsTobeReturned).when(versioningManagerMcok).listEntitiesVersionInfo
-        (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read);
-
-    VendorLicenseModelEntity vlm1 = new VendorLicenseModelEntity(vlm1_id, VERSION01);
-    vlm1.setWritetimeMicroSeconds(8L);
-    doReturn(vlm1).when(vendorLicenseModelDaoMcok).get(any(VendorLicenseModelEntity.class));
-
-    Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels
-        (VersionStatus.Final.name(), USER1);
-
-    Assert.assertEquals(vlms.size(), 1);
+  public void testValidate() {
+    // TODO: 8/13/2017
+    vendorLicenseManager.validate(vlm1_id, null);
+    verify(vendorLicenseFacadeMcok).validate(vlm1_id, null);
   }
 
   @Test
   public void testCreate() {
-
     VendorLicenseModelEntity vlmEntity = new VendorLicenseModelEntity(vlm1_id, VERSION01);
 
-    doReturn(vlmEntity).when(vendorLicenseFacadeMcok).createVendorLicenseModel(vlmEntity, USER1);
-
-    vendorLicenseManager.createVendorLicenseModel(vlmEntity, USER1);
-
-    verify(vendorLicenseFacadeMcok).createVendorLicenseModel(vlmEntity, USER1);
-    verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION01.getMajor() + 1));
-    Assert.assertTrue(activityLogEntity.isSuccess());
+    vendorLicenseManager.createVendorLicenseModel(vlmEntity);
 
+    verify(vendorLicenseModelDaoMcok).create(vlmEntity);
   }
 
   @Test
@@ -277,14 +101,6 @@ public class VendorLicenseModelTest {
     existingVlm.setVendorName("VLM1");
     existingVlm.setDescription("decription");
 
-    VersionInfo versionInfo = new VersionInfo();
-    versionInfo.setActiveVersion(VERSION01);
-
-    doReturn(versionInfo).when(vendorLicenseManager).getVersionInfo(existingVlm.getId(),
-        VersionableEntityAction.Write, USER1);
-
-    doReturn(VERSION01).when(vendorLicenseManager).resloveVersion(vlm1_id,null, versionInfo, USER1);
-
     doReturn("VLM1").when(vendorLicenseModelDaoMcok).get(existingVlm);
 
     VendorLicenseModelEntity updatedVlm = new VendorLicenseModelEntity();
@@ -302,21 +118,20 @@ public class VendorLicenseModelTest {
 
     doReturn(existingVlm).when(vendorLicenseModelDaoMcok).get(any(VendorLicenseModelEntity.class));
 
-    vendorLicenseManager.updateVendorLicenseModel(updatedVlm, USER1);
+    vendorLicenseManager.updateVendorLicenseModel(updatedVlm);
 
     verify(vendorLicenseModelDaoMcok).update(updatedVlm);
-    verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id, VERSION01);
   }
 
   @Test
-  public void testGetVendorLicenseModel(){
-    vendorLicenseManager.getVendorLicenseModel(vlm1_id,VERSION01,USER1);
-    verify(vendorLicenseFacadeMcok).getVendorLicenseModel(vlm1_id,VERSION01,USER1);
+  public void testGetVendorLicenseModel() {
+    vendorLicenseManager.getVendorLicenseModel(vlm1_id, VERSION01);
+    verify(vendorLicenseFacadeMcok).getVendorLicenseModel(vlm1_id, VERSION01);
   }
 
   @Test(expectedExceptions = UnsupportedOperationException.class)
   public void testDeleteVLMUnsupportedOperation() {
-    vendorLicenseManager.deleteVendorLicenseModel(vlm1_id, USER1);
+    vendorLicenseManager.deleteVendorLicenseModel(vlm1_id, null); // TODO: 8/13/2017
   }
 
 
@@ -324,7 +139,7 @@ public class VendorLicenseModelTest {
 //  public void testGetNonExistingVersion_negative() {
 //    Version notExistversion = new Version(43, 8);
 //    doReturn(null).when(vspInfoDaoMock).get(any(VspDetails.class));
-//    vendorSoftwareProductManager.getVsp(VSP_ID, notExistversion, USER1);
+//    vendorSoftwareProductManager.getVsp(VSP_ID, notExistversion);
 //  }
 
 }
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/licenseartifacts/impl/VendorLicenseArtifactsServiceTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/licenseartifacts/impl/VendorLicenseArtifactsServiceTest.java
index ec50c96f74..c20d96ac36 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/licenseartifacts/impl/VendorLicenseArtifactsServiceTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/licenseartifacts/impl/VendorLicenseArtifactsServiceTest.java
@@ -20,22 +20,8 @@
 
 package org.openecomp.sdc.vendorlicense.licenseartifacts.impl;
 
-import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang3.StringUtils;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.sdc.vendorlicense.ArtifactTestUtils;
-import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Test;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
 
 
 public class VendorLicenseArtifactsServiceTest extends ArtifactTestUtils {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentDependencyModelManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentDependencyModelManager.java
index a651b0bb12..869628e6f5 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentDependencyModelManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentDependencyModelManager.java
@@ -4,12 +4,17 @@ import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModel
 import org.openecomp.sdc.versioning.dao.types.Version;
 
 import java.util.Collection;
-import java.util.List;
 
 public interface ComponentDependencyModelManager {
 
-  void createComponentDependencyModel(List<ComponentDependencyModelEntity> entities, String
-      vspId, Version version, String user);
+  Collection<ComponentDependencyModelEntity> list(String vspId, Version version);
 
-  Collection<ComponentDependencyModelEntity> list(String vspId, Version version, String user);
+  ComponentDependencyModelEntity createComponentDependency(ComponentDependencyModelEntity entity,
+                                                           String vspId, Version version);
+
+  void delete(String vspId, Version version, String dependencyId);
+
+  void update(ComponentDependencyModelEntity entity);
+
+  ComponentDependencyModelEntity get(String vspId, Version version, String dependencyId);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentManager.java
index b895f5595f..413529882d 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComponentManager.java
@@ -31,24 +31,23 @@ import java.util.Collection;
 
 public interface ComponentManager {
 
-  Collection<ComponentEntity> listComponents(String vspId, Version version, String user);
+  Collection<ComponentEntity> listComponents(String vspId, Version version);
 
-  void deleteComponents(String vspId, Version version, String user);
+  void deleteComponents(String vspId, Version version);
 
-  ComponentEntity createComponent(ComponentEntity componentEntity, String user);
+  ComponentEntity createComponent(ComponentEntity componentEntity);
 
-  CompositionEntityValidationData updateComponent(ComponentEntity componentEntity, String user);
+  CompositionEntityValidationData updateComponent(ComponentEntity componentEntity);
 
   CompositionEntityResponse<ComponentData> getComponent(String vspId, Version version,
-                                                        String componentId, String user);
+                                                        String componentId);
 
-  void deleteComponent(String vspId, Version version, String componentId, String user);
+  void deleteComponent(String vspId, Version version, String componentId);
 
-  QuestionnaireResponse getQuestionnaire(String vspId, Version version, String componentId,
-                                         String user);
+  QuestionnaireResponse getQuestionnaire(String vspId, Version version, String componentId);
 
   void updateQuestionnaire(String vspId, Version version, String componentId,
-                           String questionnaireData, String user);
+                           String questionnaireData);
 
-  void validateComponentExistence(String vspId, Version version, String componentId, String user);
+  void validateComponentExistence(String vspId, Version version, String componentId);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeManager.java
index 65bceb9864..7ddd4e20c8 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeManager.java
@@ -12,23 +12,20 @@ import java.util.Collection;
 
 public interface ComputeManager {
 
-  Collection<ListComputeResponse> listCompute(String vspId, Version version, String
-      componentId, String user);
+  Collection<ListComputeResponse> listComputes(String vspId, Version version, String componentId);
 
-  ComputeEntity createCompute(ComputeEntity compute, String user);
+  ComputeEntity createCompute(ComputeEntity compute);
 
-  CompositionEntityResponse<ComputeData> getCompute(String vspId, Version version, String
-      componentId, String computeFlavorId, String user);
+  CompositionEntityResponse<ComputeData> getCompute(String vspId, Version version,
+                                                    String componentId, String computeFlavorId);
 
-  QuestionnaireResponse getComputeQuestionnaire(String vspId, Version version, String
-      componentId, String computeFlavorId, String user);
+  QuestionnaireResponse getComputeQuestionnaire(String vspId, Version version, String componentId,
+                                                String computeFlavorId);
 
-  void updateComputeQuestionnaire(String vspId, Version version, String componentId, String
-      computeId, String
-      questionnaireData, String user);
+  void updateComputeQuestionnaire(String vspId, Version version, String componentId,
+                                  String computeId, String questionnaireData);
 
-  CompositionEntityValidationData updateCompute(ComputeEntity compute, String user);
+  CompositionEntityValidationData updateCompute(ComputeEntity compute);
 
-  void deleteCompute(String vspId, Version version,String componentId, String computeFlavorId,
-                     String user);
+  void deleteCompute(String vspId, Version version, String componentId, String computeFlavorId);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorManager.java
index 51ba2f4d40..88d399aa5c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorManager.java
@@ -12,23 +12,19 @@ import java.util.Collection;
 public interface DeploymentFlavorManager {
 
 
-  DeploymentFlavorEntity createDeploymentFlavor(DeploymentFlavorEntity deploymentFlavorEntity,
-                                                String user);
+  DeploymentFlavorEntity createDeploymentFlavor(DeploymentFlavorEntity deploymentFlavorEntity);
 
-  Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version,
-                                                           String user);
+  Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version);
 
   CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavor(String vspId, Version version,
-                                                                  String deploymentFlavorId,
-                                                                  String user);
+                                                                  String deploymentFlavorId);
 
-  CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavorSchema(String vspId, Version
-      version, String user);
+  CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavorSchema(String vspId,
+                                                                        Version version);
 
-  void deleteDeploymentFlavor(String vspId, Version version, String deploymentFlavorId, String
-      user);
+  void deleteDeploymentFlavor(String vspId, Version version, String deploymentFlavorId);
 
-  CompositionEntityValidationData updateDeploymentFlavor(DeploymentFlavorEntity
-                                                             deploymentFlavorEntity, String user);
+  CompositionEntityValidationData updateDeploymentFlavor(
+      DeploymentFlavorEntity deploymentFlavorEntity);
 
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ImageManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ImageManager.java
index 6bbfc0b69a..1a53221951 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ImageManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ImageManager.java
@@ -10,24 +10,22 @@ import org.openecomp.sdc.versioning.dao.types.Version;
 import java.util.Collection;
 
 public interface ImageManager {
-  ImageEntity createImage(ImageEntity imageEntity, String user);
+  ImageEntity createImage(ImageEntity imageEntity);
 
-  CompositionEntityResponse<Image> getImageSchema(String vspId, String user);
+  CompositionEntityResponse<Image> getImageSchema(String vspId);
 
-  Collection<ImageEntity> listImages(String vspId, Version version, String componentId,
-                                     String user);
+  Collection<ImageEntity> listImages(String vspId, Version version, String componentId);
 
   CompositionEntityResponse<Image> getImage(String vspId, Version version, String componentId,
-                                            String imageId, String user);
+                                            String imageId);
 
-  QuestionnaireResponse getImageQuestionnaire(String vspId, Version version, String
-      componentId, String imageId, String user);
+  QuestionnaireResponse getImageQuestionnaire(String vspId, Version version, String componentId,
+                                              String imageId);
 
-  void deleteImage(String vspId, Version version, String componentId, String imageId, String user);
+  void deleteImage(String vspId, Version version, String componentId, String imageId);
 
-  CompositionEntityValidationData updateImage(ImageEntity imageEntity, String user);
+  CompositionEntityValidationData updateImage(ImageEntity imageEntity);
 
   void updateImageQuestionnaire(String vspId, Version version, String componentId, String imageId,
-                                String
-      questionnaireData, String user);
+                                String questionnaireData);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ManualVspToscaManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ManualVspToscaManager.java
index c9a5206383..621374ad3c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ManualVspToscaManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ManualVspToscaManager.java
@@ -6,7 +6,7 @@ import org.openecomp.sdc.versioning.dao.types.Version;
 
 public interface ManualVspToscaManager {
 
-  public VspModelInfo gatherVspInformation(String vspId, Version version, String user);
+  VspModelInfo gatherVspInformation(String vspId, Version version);
 
-  public ToscaServiceModel generateToscaModel(VspModelInfo vspModelInfo);
+  ToscaServiceModel generateToscaModel(VspModelInfo vspModelInfo);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/MonitoringUploadsManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/MonitoringUploadsManager.java
index f5e34a01be..36f06507dc 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/MonitoringUploadsManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/MonitoringUploadsManager.java
@@ -28,11 +28,10 @@ import java.io.InputStream;
 
 public interface MonitoringUploadsManager {
   void delete(String vspId, Version version, String componentId,
-              MonitoringUploadType monitoringUploadType, String user);
+              MonitoringUploadType monitoringUploadType);
 
   void upload(InputStream object, String filename, String vspId, Version version,
-              String componentId, MonitoringUploadType monitoringUploadType, String user);
+              String componentId, MonitoringUploadType monitoringUploadType);
 
-  MonitoringUploadStatus listFilenames(String vspId, Version version, String componentId,
-                                       String user);
+  MonitoringUploadStatus listFilenames(String vspId, Version version, String componentId);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NetworkManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NetworkManager.java
index b647735188..fa740690b7 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NetworkManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NetworkManager.java
@@ -29,14 +29,13 @@ import org.openecomp.sdc.versioning.dao.types.Version;
 import java.util.Collection;
 
 public interface NetworkManager {
-  Collection<NetworkEntity> listNetworks(String vspId, Version version, String user);
+  Collection<NetworkEntity> listNetworks(String vspId, Version version);
 
-  NetworkEntity createNetwork(NetworkEntity network, String user);
+  NetworkEntity createNetwork(NetworkEntity network);
 
-  CompositionEntityValidationData updateNetwork(NetworkEntity networkEntity, String user);
+  CompositionEntityValidationData updateNetwork(NetworkEntity networkEntity);
 
-  CompositionEntityResponse<Network> getNetwork(String vspId, Version version, String networkId,
-                                                String user);
+  CompositionEntityResponse<Network> getNetwork(String vspId, Version version, String networkId);
 
-  void deleteNetwork(String vspId, Version version, String networkId, String user);
+  void deleteNetwork(String vspId, Version version, String networkId);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NicManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NicManager.java
index 466583edfd..b055d97ef3 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NicManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/NicManager.java
@@ -31,20 +31,20 @@ import java.util.Collection;
 
 public interface NicManager {
 
-  Collection<NicEntity> listNics(String vspId, Version version, String componentId, String user);
+  Collection<NicEntity> listNics(String vspId, Version version, String componentId);
 
-  NicEntity createNic(NicEntity nic, String user);
+  NicEntity createNic(NicEntity nic);
 
-  CompositionEntityValidationData updateNic(NicEntity nicEntity, String user);
+  CompositionEntityValidationData updateNic(NicEntity nicEntity);
 
   CompositionEntityResponse<Nic> getNic(String vspId, Version version, String componentId,
-                                        String nicId, String user);
+                                        String nicId);
 
-  void deleteNic(String vspId, Version version, String componentId, String nicId, String user);
+  void deleteNic(String vspId, Version version, String componentId, String nicId);
 
   QuestionnaireResponse getNicQuestionnaire(String vspId, Version version, String componentId,
-                                            String nicId, String user);
+                                            String nicId);
 
   void updateNicQuestionnaire(String vspId, Version version, String componentId, String nicId,
-                              String questionnaireData, String user);
+                              String questionnaireData);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/OrchestrationTemplateCandidateManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/OrchestrationTemplateCandidateManager.java
index e2ef86149b..84318dbdd8 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/OrchestrationTemplateCandidateManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/OrchestrationTemplateCandidateManager.java
@@ -21,6 +21,7 @@
 package org.openecomp.sdc.vendorsoftwareproduct;
 
 import org.apache.commons.lang3.tuple.Pair;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateCandidateData;
 import org.openecomp.sdc.vendorsoftwareproduct.types.OrchestrationTemplateActionResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
@@ -33,14 +34,16 @@ import java.util.Optional;
 
 public interface OrchestrationTemplateCandidateManager {
   UploadFileResponse upload(String vspId, Version version, InputStream heatFileToUpload,
-                            String user, String filePrefix, String networkPackageName);
+                            String fileSuffix, String networkPackageName);
 
-  OrchestrationTemplateActionResponse process(String vspId, Version version, String user);
+  OrchestrationTemplateActionResponse process(String vspId, Version version);
 
-  Optional<FilesDataStructure> getFilesDataStructure(String vspId, Version version, String user);
+  Optional<FilesDataStructure> getFilesDataStructure(String vspId, Version version);
 
-  ValidationResponse updateFilesDataStructure(String vspId, Version version, String user,
+  ValidationResponse updateFilesDataStructure(String vspId, Version version,
                                               FilesDataStructure fileDataStructure);
 
-  Optional<Pair<String, byte[]>> get(String vspId, Version version, String user) throws IOException;
+  Optional<Pair<String, byte[]>> get(String vspId, Version version) throws IOException;
+
+  OrchestrationTemplateCandidateData getInfo(String vspId, Version version);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ProcessManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ProcessManager.java
index afe88d2053..979eea0fb8 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ProcessManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/ProcessManager.java
@@ -28,27 +28,22 @@ import java.io.InputStream;
 import java.util.Collection;
 
 public interface ProcessManager {
-  Collection<ProcessEntity> listProcesses(String vspId, Version version, String componentId,
-                                          String user);
+  Collection<ProcessEntity> listProcesses(String vspId, Version version, String componentId);
 
-  void deleteProcesses(String vspId, Version version, String componentId, String user);
+  void deleteProcesses(String vspId, Version version, String componentId);
 
-  ProcessEntity createProcess(ProcessEntity processEntity, String user);
+  ProcessEntity createProcess(ProcessEntity processEntity);
 
-  ProcessEntity getProcess(String vspId, Version version, String componentId, String processId,
-                           String user);
+  ProcessEntity getProcess(String vspId, Version version, String componentId, String processId);
 
-  void updateProcess(ProcessEntity processEntity, String user);
+  void updateProcess(ProcessEntity processEntity);
 
-  void deleteProcess(String vspId, Version version, String componentId, String processId,
-                     String user);
+  void deleteProcess(String vspId, Version version, String componentId, String processId);
 
-  File getProcessArtifact(String vspId, Version version, String componentId, String processId,
-                          String user);
+  File getProcessArtifact(String vspId, Version version, String componentId, String processId);
 
-  void deleteProcessArtifact(String vspId, Version version, String componentId, String processId,
-                             String user);
+  void deleteProcessArtifact(String vspId, Version version, String componentId, String processId);
 
   void uploadProcessArtifact(InputStream uploadFile, String fileName, String vspId,
-                             Version version, String componentId, String processId, String user);
+                             Version version, String componentId, String processId);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/VendorSoftwareProductManager.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/VendorSoftwareProductManager.java
index 0adca1c695..2e38122856 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/VendorSoftwareProductManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/VendorSoftwareProductManager.java
@@ -20,65 +20,55 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct;
 
+import org.openecomp.sdc.datatypes.error.ErrorMessage;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.VersionedVendorSoftwareProductInfo;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.types.VersionInfo;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 
 public interface VendorSoftwareProductManager {
 
-  Version checkout(String vendorSoftwareProductId, String user);
+  VspDetails createVsp(VspDetails vspDetails);
 
-  Version undoCheckout(String vendorSoftwareProductId, String user);
+  void updateVsp(VspDetails vspDetails);
 
-  Version checkin(String vendorSoftwareProductId, String user);
+  VspDetails getVsp(String vspId, Version version);
 
-  ValidationResponse submit(String vendorSoftwareProductId, String user) throws IOException;
+  void deleteVsp(String vspIdToDelete);
 
+  ValidationResponse validate(String vspId, Version version) throws IOException;
 
-  List<VersionedVendorSoftwareProductInfo> listVsps(String versionFilter, String user);
+  Map<String, List<ErrorMessage>> compile(String vspId, Version version);
 
-  VspDetails createVsp(VspDetails vspDetails, String user);
 
-  void updateVsp(VspDetails vspDetails, String user);
+  QuestionnaireResponse getVspQuestionnaire(String vspId, Version version);
 
-  VspDetails getVsp(String vspId, Version version, String user);
+  void updateVspQuestionnaire(String vspId, Version version, String questionnaireData);
 
-  Version callAutoHeal(String vspId, VersionInfo versionInfo,
-                       VspDetails vendorSoftwareProductInfo, String user) throws Exception;
 
-  void deleteVsp(String vspIdToDelete, String user);
+  byte[] getOrchestrationTemplateFile(String vspId, Version version);
 
-  QuestionnaireResponse getVspQuestionnaire(String vspId, Version version, String user);
+  OrchestrationTemplateEntity getOrchestrationTemplateInfo(String vspId, Version version);
 
-  void updateVspQuestionnaire(String vspId, Version version, String questionnaireData, String user);
 
-
-  byte[] getOrchestrationTemplateFile(String vspId, Version version, String user);
-
-  PackageInfo createPackage(String vspId, Version version, String user) throws IOException;
+  PackageInfo createPackage(String vspId, Version version) throws IOException;
 
   List<PackageInfo> listPackages(String category, String subCategory);
 
-  File getTranslatedFile(String vspId, Version version, String user);
-
-  void heal(String vspId, Version version, String user);
 
-  File getInformationArtifact(String vspId, Version version, String user);
+  File getTranslatedFile(String vspId, Version version);
 
-  String fetchValidationVsp(String user);
+  File getInformationArtifact(String vspId, Version version);
 
-  Collection<ComputeEntity> getComputeByVsp(String vspId, Version version, String user);
 
-  Version healAndAdvanceFinalVersion(String vspId, VspDetails vendorSoftwareProductInfo,
-                                     String user) throws IOException;
+  Collection<ComputeEntity> getComputeByVsp(String vspId, Version version);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ComponentDependencyModelErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ComponentDependencyModelErrorBuilder.java
index 78605c86fc..53ad74b772 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ComponentDependencyModelErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ComponentDependencyModelErrorBuilder.java
@@ -1,18 +1,14 @@
 package org.openecomp.sdc.vendorsoftwareproduct.errors;
 
 
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes
-    .CYCLIC_DEPENDENCY_IN_COMPONENTS;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes
-    .INVALID_COMPONENT_RELATION_TYPE;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes
-    .NO_SOURCE_COMPONENT;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes
-    .SAME_SOURCE_TARGET_COMPONENT;
-
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.CYCLIC_DEPENDENCY_IN_COMPONENTS;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.INVALID_COMPONENT_RELATION_TYPE;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.NO_SOURCE_COMPONENT;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.SAME_SOURCE_TARGET_COMPONENT;
+
 public class ComponentDependencyModelErrorBuilder {
 
   private static final String CYCLIC_DEPENDENCY_COMPONENT_MSG = "Cyclic dependency exists between"
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/DuplicateComputeInComponentErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/DuplicateComputeInComponentErrorBuilder.java
index b242b7169c..5d58f5c35b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/DuplicateComputeInComponentErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/DuplicateComputeInComponentErrorBuilder.java
@@ -2,41 +2,16 @@ package org.openecomp.sdc.vendorsoftwareproduct.errors;
 
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
+
 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.UPDATE_COMPUTE_NOT_ALLOWED;
 
 
 public class DuplicateComputeInComponentErrorBuilder {
-
-  private static final String DUPLICATE_COMPUTE_NAME_NOT_ALLOWED_MSG =
-      "Invalid request, Compute with name %s already exists for component with ID %s.";
-  private static final String COMPUTE_HEAT_READONLY_ATTR_MSG = "Update of attribute %s not allowed "
-          + "for VSP onboarded via HEAT.";
-  private static final String COMPUTE_MANUAL_READONLY_ATTR_MSG = "Update of attribute %s not allowed "
-          + "for VSP onboarded manually.";
-
+  private static final String COMPUTE_HEAT_READONLY_ATTR_MSG =
+      "Update of attribute %s not allowed for VSP onboarded via HEAT.";
 
   private final ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
 
-  public DuplicateComputeInComponentErrorBuilder(String computeName, String componentId ){
-    builder.withId(VendorSoftwareProductErrorCodes.DUPLICATE_COMPUTE_NAME_NOT_ALLOWED);
-    builder.withCategory(ErrorCategory.APPLICATION);
-    builder.withMessage(String.format(DUPLICATE_COMPUTE_NAME_NOT_ALLOWED_MSG,computeName,
-        componentId));
-  }
-
-  /**
-   * Gets duplicate compute name error builder.
-   *
-   * @return the duplicate compute name error builder
-   */
-  public static ErrorCode getDuplicateComputeNameErrorBuilder(String computeName, String componenetId) {
-    ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
-    builder.withId(VendorSoftwareProductErrorCodes.DUPLICATE_COMPUTE_NAME_NOT_ALLOWED);
-    builder.withCategory(ErrorCategory.APPLICATION);
-    builder.withMessage(String.format(DUPLICATE_COMPUTE_NAME_NOT_ALLOWED_MSG, computeName, componenetId ));
-    return builder.build();
-  }
-
   public static ErrorCode getComputeHeatReadOnlyErrorBuilder(String name) {
     ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
     builder.withId(UPDATE_COMPUTE_NOT_ALLOWED);
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ImageErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ImageErrorBuilder.java
index 9ac6e1b1bb..2d22d01774 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ImageErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/ImageErrorBuilder.java
@@ -3,7 +3,11 @@ package org.openecomp.sdc.vendorsoftwareproduct.errors;
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.*;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_NAME_NOT_ALLOWED;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_VERSION_NOT_ALLOWED;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.IMAGE_NAME_FORMAT_NOT_ALLOWED;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT;
 
 /**
  * The Image error builder.
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/MonitoringUploadErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/MonitoringUploadErrorBuilder.java
index 5fc29d5a4f..eed56e1a1a 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/MonitoringUploadErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/MonitoringUploadErrorBuilder.java
@@ -28,8 +28,7 @@ import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProdu
 
 public class MonitoringUploadErrorBuilder extends BaseErrorBuilder {
   private static final String UPLOAD_INVALID_DETAILED_MSG =
-      "Monitoring file uploaded for vendor software product with Id %s and version %s is invalid:" +
-          " %s";
+      "Monitoring file uploaded for vendor software product with Id %s and version %s is invalid: %s";
 
 
   /**
@@ -44,7 +43,7 @@ public class MonitoringUploadErrorBuilder extends BaseErrorBuilder {
     getErrorCodeBuilder().withId(MONITORING_UPLOAD_INVALID);
     getErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION);
     getErrorCodeBuilder().withMessage(String.format(UPLOAD_INVALID_DETAILED_MSG,
-        vendorSoftwareProductId, version == null ? null : version.toString(), error));
+        vendorSoftwareProductId, version == null ? null : version.getId(), error));
   }
 
   /**
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NicInternalNetworkErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NicInternalNetworkErrorBuilder.java
index 0850d2e704..2acfde48ff 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NicInternalNetworkErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NicInternalNetworkErrorBuilder.java
@@ -1,11 +1,11 @@
 package org.openecomp.sdc.vendorsoftwareproduct.errors;
 
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.NETWORK_DESCRIPTION_NOT_ALLOWED_FOR_INTERNAL_NETWORK;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.NETWORK_TYPE_UPDATE_NOT_ALLOWED;
-
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.NETWORK_DESCRIPTION_NOT_ALLOWED_FOR_INTERNAL_NETWORK;
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.NETWORK_TYPE_UPDATE_NOT_ALLOWED;
+
 public class NicInternalNetworkErrorBuilder {
   private static final String NULL_NETWORKID_NOT_ALLOWED_MSG =
       "Internal Networks are currently not supported for VSP created Manually, so please fix all the NIC to be of Type External and re-submit the VSP.";
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NotSupportedHeatOnboardMethodErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NotSupportedHeatOnboardMethodErrorBuilder.java
index 7801df8fd7..1b6896211b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NotSupportedHeatOnboardMethodErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/NotSupportedHeatOnboardMethodErrorBuilder.java
@@ -1,5 +1,8 @@
 package org.openecomp.sdc.vendorsoftwareproduct.errors;
 
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+
 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.ADD_COMPUTE_NOT_ALLOWED_IN_HEAT_ONBOARDING;
 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING;
 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.ADD_NIC_NOT_ALLOWED_IN_HEAT_ONBOARDING;
@@ -7,9 +10,6 @@ import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProdu
 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.DELETE_IMAGE_NOT_ALLOWED;
 import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.EDIT_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING;
 
-import org.openecomp.sdc.common.errors.ErrorCategory;
-import org.openecomp.sdc.common.errors.ErrorCode;
-
 public class NotSupportedHeatOnboardMethodErrorBuilder {
   private static final String ADD_NIC_NOT_ALLOWED_IN_HEAT_ONBOARDING_MSG =
       "NIC cannot be added for VSPs onboarded with HEAT.";
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/OnboardingMethodErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/OnboardingMethodErrorBuilder.java
index 8aad900102..49785a38f8 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/OnboardingMethodErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/OnboardingMethodErrorBuilder.java
@@ -1,37 +1,19 @@
 package org.openecomp.sdc.vendorsoftwareproduct.errors;
 
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes
-    .VSP_INVALID_ONBOARDING_METHOD;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes
-    .VSP_ONBOARD_METHOD_UPDATE_NOT_ALLOWED;
-
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.VSP_INVALID_ONBOARDING_METHOD;
+
 /**
  * The type Onboarding method error builder.
  */
 public class OnboardingMethodErrorBuilder {
 
-  private static final String VSP_ONBOARD_METHOD_UPDATE_NOT_ALLOWED_MSG =
-      "onboardingMethod update is not allowed.";
   private static final String VSP_INVALID_ONBOARDING_METHOD_MSG =
       "The onboardingMethod value doesn't meet the expected attribute value.";
 
   /**
-   * Gets onboarding update error.
-   *
-   * @return the onboarding update error
-   */
-  public static ErrorCode getOnboardingUpdateError() {
-    ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
-    builder.withId(VSP_ONBOARD_METHOD_UPDATE_NOT_ALLOWED);
-    builder.withCategory(ErrorCategory.APPLICATION);
-    builder.withMessage(String.format(VSP_ONBOARD_METHOD_UPDATE_NOT_ALLOWED_MSG));
-    return builder.build();
-  }
-
-  /**
    * Get invalid onboarding method error builder error code.
    *
    * @return the error code
@@ -40,7 +22,7 @@ public class OnboardingMethodErrorBuilder {
     ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
     builder.withId(VSP_INVALID_ONBOARDING_METHOD);
     builder.withCategory(ErrorCategory.APPLICATION);
-    builder.withMessage(String.format(VSP_INVALID_ONBOARDING_METHOD_MSG));
+    builder.withMessage(VSP_INVALID_ONBOARDING_METHOD_MSG);
     return builder.build();
   }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/TranslationFileCreationErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/TranslationFileCreationErrorBuilder.java
index 1ec3af397f..fd8acd1497 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/TranslationFileCreationErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/TranslationFileCreationErrorBuilder.java
@@ -20,12 +20,12 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct.errors;
 
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.TRANSLATION_FILE_CREATION;
-
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.versioning.dao.types.Version;
 
+import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.TRANSLATION_FILE_CREATION;
+
 public class TranslationFileCreationErrorBuilder {
   private static final String TRANSLATION_FILE_CREATION_ERROR_MSG =
       "Error while trying to create translation file from the package of vendor software product "
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/VendorSoftwareProductInvalidErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/VendorSoftwareProductInvalidErrorBuilder.java
index 4a84c83338..4fc0b6e6f7 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/VendorSoftwareProductInvalidErrorBuilder.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/errors/VendorSoftwareProductInvalidErrorBuilder.java
@@ -28,7 +28,7 @@ public class VendorSoftwareProductInvalidErrorBuilder {
   private static final String VSP_INVALID_MSG =
       "Vendor software product with Id %s and version %s is invalid - does not contain "
           + "service model.";
-  private static final String VSP_INVALID_MISSING_DEPLOYMENT_FLAVOR_MSG ="VSP has to have a " +
+  private static final String VSP_INVALID_MISSING_DEPLOYMENT_FLAVOR_MSG = "VSP has to have a " +
       "minimum of one Deployment Flavor defined for being able to be instantiated.Please add a Deployment Flavor and re-submit the VSP.";
   private final ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
 
@@ -39,13 +39,13 @@ public class VendorSoftwareProductInvalidErrorBuilder {
    * @param version                 the version
    */
   public static ErrorCode VendorSoftwareProductMissingServiceModelErrorBuilder(String
-                                                                         vendorSoftwareProductId,
-                                                             Version version) {
+                                                                                   vendorSoftwareProductId,
+                                                                               Version version) {
     ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
     builder.withId(VendorSoftwareProductErrorCodes.VSP_INVALID);
     builder.withCategory(ErrorCategory.APPLICATION);
     builder
-        .withMessage(String.format(VSP_INVALID_MSG, vendorSoftwareProductId, version.toString()));
+        .withMessage(String.format(VSP_INVALID_MSG, vendorSoftwareProductId, version.getId()));
     return builder.build();
   }
 
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerFactoryImpl.java
index b4513dec79..1f9a35cb2c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerFactoryImpl.java
@@ -3,13 +3,16 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl;
 import org.openecomp.sdc.vendorsoftwareproduct.ComponentDependencyModelManager;
 import org.openecomp.sdc.vendorsoftwareproduct.ComponentDependencyModelManagerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.ComponentManagerFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDaoFactory;
 
 public class ComponentDependencyModelManagerFactoryImpl extends
     ComponentDependencyModelManagerFactory {
+
   private static final ComponentDependencyModelManager INSTANCE =
-      new ComponentDependencyModelManagerImpl(VendorSoftwareProductDaoFactory.getInstance()
-          .createInterface(), ComponentManagerFactory.getInstance().createInterface());
+      new ComponentDependencyModelManagerImpl(
+          ComponentManagerFactory.getInstance().createInterface(),
+          ComponentDependencyModelDaoFactory.getInstance().createInterface()
+      );
 
   @Override
   public ComponentDependencyModelManager createInterface() {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerImpl.java
index 5dc1446601..17d1833af6 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelManagerImpl.java
@@ -1,6 +1,7 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 import org.apache.commons.lang3.StringUtils;
+import org.openecomp.core.utilities.CommonMethods;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
@@ -12,72 +13,114 @@ import org.openecomp.sdc.logging.types.LoggerConstants;
 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
 import org.openecomp.sdc.vendorsoftwareproduct.ComponentDependencyModelManager;
 import org.openecomp.sdc.vendorsoftwareproduct.ComponentManager;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentDependencyModelErrorBuilder;
+import org.openecomp.sdc.versioning.VersioningUtil;
 import org.openecomp.sdc.versioning.dao.types.Version;
 
 import java.util.Collection;
-import java.util.List;
 
 public class ComponentDependencyModelManagerImpl implements ComponentDependencyModelManager {
 
-  private VendorSoftwareProductDao vendorSoftwareProductDao;
   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
   protected static final Logger logger =
       LoggerFactory.getLogger(ComponentDependencyModelManagerImpl.class);
 
   private ComponentManager componentManager;
+  private ComponentDependencyModelDao componentDependencyModelDao;
 
-  public ComponentDependencyModelManagerImpl(VendorSoftwareProductDao vendorSoftwareProductDao, ComponentManager componentManager) {
-    this.vendorSoftwareProductDao = vendorSoftwareProductDao;
+  public ComponentDependencyModelManagerImpl(
+      ComponentManager componentManager, ComponentDependencyModelDao componentDependencyModelDao) {
     this.componentManager = componentManager;
+    this.componentDependencyModelDao = componentDependencyModelDao;
+  }
+
+  private void raiseException(ErrorCode errorCode) {
+    MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
+        LoggerTragetServiceName.CREATE_COMPONENT_DEPENDENCY_MODEL, ErrorLevel.ERROR.name(),
+        errorCode.id(), errorCode.message());
+    throw new CoreException(errorCode);
   }
 
   @Override
-  public void createComponentDependencyModel(List<ComponentDependencyModelEntity> entities,
-                                             String vspId, Version version, String user) {
-
-    mdcDataDebugMessage.debugEntryMessage("createComponentDependencyModel");
-    for(ComponentDependencyModelEntity entity : entities) {
-      if (!StringUtils.isEmpty(entity.getSourceComponentId())) {
-        componentManager.validateComponentExistence(entity.getVspId(), entity.getVersion(),
-            entity.getSourceComponentId(), user);
-        if (entity.getSourceComponentId().equals(entity.getTargetComponentId())) {
-          ErrorCode errorCode =
-              ComponentDependencyModelErrorBuilder.getSourceTargetComponentEqualErrorBuilder();
-          raiseException(errorCode);
-        }
-      } else {
-          ErrorCode errorCode = ComponentDependencyModelErrorBuilder
-              .getNoSourceComponentErrorBuilder();
-          raiseException(errorCode);
-      }
+  public Collection<ComponentDependencyModelEntity> list(String vspId, Version version) {
+
+    mdcDataDebugMessage.debugExitMessage("VSP id, version", vspId, version.toString());
+
+    return componentDependencyModelDao
+        .list(new ComponentDependencyModelEntity(vspId, version, null));
+  }
+
+  @Override
+  public ComponentDependencyModelEntity createComponentDependency(ComponentDependencyModelEntity
+                                                                      entity, String vspId,
+                                                                  Version version) {
+
+    validateComponentDependency(entity);
+    entity.setId(CommonMethods.nextUuId());
+    componentDependencyModelDao.create(entity);
+    return entity;
+  }
 
-      if (!StringUtils.isEmpty(entity.getTargetComponentId())) {
-        componentManager.validateComponentExistence(entity.getVspId(), entity.getVersion(),
-            entity.getTargetComponentId(), user);
+  private void validateComponentDependency(ComponentDependencyModelEntity entity) {
+    if (!StringUtils.isEmpty(entity.getSourceComponentId())) {
+      componentManager.validateComponentExistence(entity.getVspId(), entity.getVersion(),
+          entity.getSourceComponentId());
+      if (entity.getSourceComponentId().equals(entity.getTargetComponentId())) {
+        ErrorCode errorCode =
+            ComponentDependencyModelErrorBuilder.getSourceTargetComponentEqualErrorBuilder();
+        raiseException(errorCode);
       }
+    } else {
+      ErrorCode errorCode = ComponentDependencyModelErrorBuilder
+          .getNoSourceComponentErrorBuilder();
+      raiseException(errorCode);
     }
 
-    vendorSoftwareProductDao.createComponentDependencyModel(entities, vspId, version );
-
-    mdcDataDebugMessage.debugExitMessage("createComponentDependencyModel");
+    if (!StringUtils.isEmpty(entity.getTargetComponentId())) {
+      componentManager.validateComponentExistence(entity.getVspId(), entity.getVersion(),
+          entity.getTargetComponentId());
+    }
   }
 
-  private void raiseException(ErrorCode errorCode) {
-    MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
-        LoggerTragetServiceName.CREATE_COMPONENT_DEPENDENCY_MODEL, ErrorLevel.ERROR.name(),
-        errorCode.id(), errorCode.message());
-    throw new CoreException(errorCode);
+  @Override
+  public void delete(String vspId, Version version, String dependencyId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, dependencyId", vspId, dependencyId);
+    ComponentDependencyModelEntity componentDependencyEntity = getComponentDependency(vspId,
+        version, dependencyId);
+    if (componentDependencyEntity != null) {
+      componentDependencyModelDao.delete(componentDependencyEntity);
+    }
+
+    mdcDataDebugMessage.debugExitMessage("VSP id, dependencyId", vspId, dependencyId);
   }
 
   @Override
-  public Collection<ComponentDependencyModelEntity> list(String vspId, Version version, String
-      user) {
+  public void update(ComponentDependencyModelEntity entity) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, dependencyId", entity.getVspId(),
+        entity.getId());
+    ComponentDependencyModelEntity componentDependencyEntity = getComponentDependency(
+        entity.getVspId(), entity.getVersion(), entity.getId());
+    validateComponentDependency(entity);
+    componentDependencyModelDao.update(entity);
+  }
 
-    mdcDataDebugMessage.debugExitMessage("VSP id, version", vspId, version.toString());
+  @Override
+  public ComponentDependencyModelEntity get(String vspId, Version version, String dependencyId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, dependencyId", vspId, dependencyId);
+    ComponentDependencyModelEntity componentDependency =
+        getComponentDependency(vspId, version, dependencyId);
+    return componentDependency;
+  }
 
-    return vendorSoftwareProductDao.listComponentDependencies(vspId, version);
+  private ComponentDependencyModelEntity getComponentDependency(String vspId, Version version,
+                                                                String dependencyId) {
+    ComponentDependencyModelEntity retrieved = componentDependencyModelDao.get(
+        new ComponentDependencyModelEntity(vspId, version, dependencyId));
+    VersioningUtil.validateEntityExistence(retrieved, new ComponentDependencyModelEntity(
+        vspId, version, dependencyId), VspDetails.ENTITY_TYPE);
+    return retrieved;
   }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImpl.java
index 72a38bbb5d..1834bf05d6 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImpl.java
@@ -67,10 +67,10 @@ public class ComponentManagerImpl implements ComponentManager {
   private NicManager nicManager;
   private VendorSoftwareProductInfoDao vspInfoDao;
 
-  public ComponentManagerImpl(
-      ComponentDao componentDao,
-      CompositionEntityDataManager compositionEntityDataManager,
-      NicManager nicManager, VendorSoftwareProductInfoDao vspInfoDao) {
+  public ComponentManagerImpl(ComponentDao componentDao,
+                              CompositionEntityDataManager compositionEntityDataManager,
+                              NicManager nicManager,
+                              VendorSoftwareProductInfoDao vspInfoDao) {
     this.componentDao = componentDao;
     this.compositionEntityDataManager = compositionEntityDataManager;
     this.nicManager = nicManager;
@@ -78,14 +78,14 @@ public class ComponentManagerImpl implements ComponentManager {
   }
 
   @Override
-  public Collection<ComponentEntity> listComponents(String vspId, Version version, String user) {
+  public Collection<ComponentEntity> listComponents(String vspId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
     return componentDao.list(new ComponentEntity(vspId, version, null));
   }
 
   @Override
-  public void deleteComponents(String vspId, Version version, String user) {
+  public void deleteComponents(String vspId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
     if (!vspInfoDao.isManual(vspId, version)) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
@@ -95,12 +95,11 @@ public class ComponentManagerImpl implements ComponentManager {
           new CompositionEditNotAllowedErrorBuilder(vspId, version).build());
     }
 
-    //componentDao.updateVspLatestModificationTime(vspId, version);
     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
   }
 
   /*@Override
-  public ComponentEntity createComponent(ComponentEntity component, String user) {
+  public ComponentEntity createComponent(ComponentEntity component) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", component.getId());
 
     if (!isManual(component.getVspId(), component.getVersion())) {
@@ -112,24 +111,18 @@ public class ComponentManagerImpl implements ComponentManager {
               .build());
 
     }
-    //componentDao.updateVspLatestModificationTime(component.getVspId(), component.getVersion());
     mdcDataDebugMessage.debugExitMessage("VSP id", component.getId());
     return null;
   }*/
 
   @Override
-  public ComponentEntity createComponent(ComponentEntity component, String user) {
+  public ComponentEntity createComponent(ComponentEntity component) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", component.getId());
-    /*Version activeVersion =
-        getVersionInfo(component.getVspId(), VersionableEntityAction.Write, user)
-            .getActiveVersion();
-    component.setVersion(activeVersion);*/
 
     final String VFC_ADD_NOT_ALLOWED_IN_HEAT_ONBOARDING_MSG =
         "VFCs cannot be added for VSPs onboarded with HEAT.";
 
-    ComponentEntity createdComponent = null;
-
+    ComponentEntity createdComponent;
     if (!vspInfoDao.isManual(component.getVspId(), component.getVersion())) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.CREATE_COMPONENT, ErrorLevel.ERROR.name(),
@@ -141,7 +134,7 @@ public class ComponentManagerImpl implements ComponentManager {
     } else {
       validateComponentManual(component);
       updateComponentName(component);
-      createdComponent = createComponent(component);
+      createdComponent = compositionEntityDataManager.createComponent(component);
     }
 
     mdcDataDebugMessage.debugExitMessage("VSP id", component.getId());
@@ -149,10 +142,6 @@ public class ComponentManagerImpl implements ComponentManager {
     return createdComponent;
   }
 
-  private ComponentEntity createComponent(ComponentEntity component) {
-    return compositionEntityDataManager.createComponent(component);
-  }
-
   private void updateComponentName(ComponentEntity component) {
     ComponentData data = component.getComponentCompositionData();
     data.setName(COMPUTE_TYPE_PREFIX + data.getDisplayName());
@@ -166,8 +155,8 @@ public class ComponentManagerImpl implements ComponentManager {
     final String VSP_VFC_DUPLICATE_NAME_MSG = "VFC with specified name "
         + "already present in given VSP.";
 
-    Collection<ComponentEntity> vspComponentList = listComponents(component.getVspId()
-        , component.getVersion(), null);
+    Collection<ComponentEntity> vspComponentList =
+        listComponents(component.getVspId(), component.getVersion());
     if (vspComponentList.size() >= 1) //1707 release only supports 1 VFC in VSP (manual creation)
     {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
@@ -202,18 +191,17 @@ public class ComponentManagerImpl implements ComponentManager {
   }
 
   @Override
-  public CompositionEntityValidationData updateComponent(ComponentEntity component, String user) {
+  public CompositionEntityValidationData updateComponent(ComponentEntity component) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", component
         .getVspId(), component.getId());
     ComponentEntity retrieved =
-        getComponent(component.getVspId(), component.getVersion(), component.getId());
+        getValidatedComponent(component.getVspId(), component.getVersion(), component.getId());
 
     boolean isManual = vspInfoDao.isManual(component.getVspId(), component.getVersion());
     if (isManual) {
-      validateComponentUpdateManual(component, retrieved, user);
+      validateComponentUpdateManual(retrieved);
     }
 
-
     ComponentCompositionSchemaInput schemaInput = new ComponentCompositionSchemaInput();
     schemaInput.setManual(isManual);
     schemaInput.setComponent(retrieved.getComponentCompositionData());
@@ -232,19 +220,18 @@ public class ComponentManagerImpl implements ComponentManager {
     return validationData;
   }
 
-  private void validateComponentUpdateManual(ComponentEntity component, ComponentEntity
-      retrieved, String user) {
+  private void validateComponentUpdateManual(ComponentEntity component) {
     Collection<ComponentEntity> vspComponentList =
-        listComponents(component.getVspId(), component.getVersion(), user);
+        listComponents(component.getVspId(), component.getVersion());
     //VFC name should be unique within VSP
     //Removing VFC with same ID from list to avoid self compare
-    for(ComponentEntity ce : vspComponentList) {
+    for (ComponentEntity ce : vspComponentList) {
       if (ce.getId().equals(component.getId())) {
         vspComponentList.remove(ce);
         break;
       }
     }
-    if (!isVfcNameUnique(vspComponentList,  component.getComponentCompositionData()
+    if (!isVfcNameUnique(vspComponentList, component.getComponentCompositionData()
         .getDisplayName())) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.UPDATE_COMPONENT, ErrorLevel.ERROR.name(),
@@ -259,9 +246,9 @@ public class ComponentManagerImpl implements ComponentManager {
   }
 
   public CompositionEntityResponse<ComponentData> getComponent(String vspId, Version version,
-                                                               String componentId, String user) {
+                                                               String componentId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
-    ComponentEntity componentEntity = getComponent(vspId, version, componentId);
+    ComponentEntity componentEntity = getValidatedComponent(vspId, version, componentId);
     ComponentData component = componentEntity.getComponentCompositionData();
 
     ComponentCompositionSchemaInput schemaInput = new ComponentCompositionSchemaInput();
@@ -278,7 +265,7 @@ public class ComponentManagerImpl implements ComponentManager {
   }
 
   @Override
-  public void deleteComponent(String vspId, Version version, String componentId, String user) {
+  public void deleteComponent(String vspId, Version version, String componentId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
     if (!vspInfoDao.isManual(vspId, version)) {
@@ -289,14 +276,12 @@ public class ComponentManagerImpl implements ComponentManager {
           new CompositionEditNotAllowedErrorBuilder(vspId, version).build());
     }
 
-    //componentDao.updateVspLatestModificationTime(vspId, version);
-
     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
   }
 
   @Override
   public QuestionnaireResponse getQuestionnaire(String vspId, Version version,
-                                                String componentId, String user) {
+                                                String componentId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
@@ -306,7 +291,7 @@ public class ComponentManagerImpl implements ComponentManager {
             VspDetails.ENTITY_TYPE);
 
     questionnaireResponse.setData(component.getQuestionnaireData());
-    List<String> nicNames = nicManager.listNics(vspId, version, componentId, user).stream()
+    List<String> nicNames = nicManager.listNics(vspId, version, componentId).stream()
         .map(nic -> nic.getNicCompositionData().getName()).collect(Collectors.toList());
     questionnaireResponse.setSchema(getComponentQuestionnaireSchema(
         new ComponentQuestionnaireSchemaInput(nicNames, questionnaireResponse.getData() == null
@@ -319,23 +304,21 @@ public class ComponentManagerImpl implements ComponentManager {
 
   @Override
   public void updateQuestionnaire(String vspId, Version version, String componentId,
-                                  String questionnaireData, String user) {
+                                  String questionnaireData) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
-    validateComponentExistence(vspId, version, componentId, user);
+    validateComponentExistence(vspId, version, componentId);
 
     componentDao.updateQuestionnaireData(vspId, version, componentId, questionnaireData);
 
-    //componentDao.updateVspLatestModificationTime(vspId, version);
     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
   }
 
   @Override
-  public void validateComponentExistence(String vspId, Version version, String componentId,
-                                         String user) {
-    getComponent(vspId, version, componentId);
+  public void validateComponentExistence(String vspId, Version version, String componentId) {
+    getValidatedComponent(vspId, version, componentId);
   }
 
-  private ComponentEntity getComponent(String vspId, Version version, String componentId) {
+  private ComponentEntity getValidatedComponent(String vspId, Version version, String componentId) {
     ComponentEntity retrieved = componentDao.get(new ComponentEntity(vspId, version, componentId));
     VersioningUtil
         .validateEntityExistence(retrieved, new ComponentEntity(vspId, version, componentId),
@@ -353,8 +336,4 @@ public class ComponentManagerImpl implements ComponentManager {
         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.component,
             schemaInput);
   }
-
-  /*private boolean isManual(String vspId, Version version) {
-    return false;
-  }*/
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerFactoryImpl.java
index 71985fa83e..598c45f323 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerFactoryImpl.java
@@ -2,7 +2,6 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 import org.openecomp.sdc.vendorsoftwareproduct.ComputeManager;
 import org.openecomp.sdc.vendorsoftwareproduct.ComputeManagerFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
@@ -15,10 +14,7 @@ public class ComputeManagerFactoryImpl extends ComputeManagerFactory {
           VendorSoftwareProductInfoDaoFactory.getInstance().createInterface(),
           ComputeDaoFactory.getInstance().createInterface(),
           CompositionEntityDataManagerFactory.getInstance().createInterface(),
-          DeploymentFlavorDaoFactory.getInstance().createInterface(),
-          ComponentDaoFactory.getInstance().createInterface()
-
-      );
+          DeploymentFlavorDaoFactory.getInstance().createInterface());
 
   @Override
   public ComputeManager createInterface() {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImpl.java
index be90b08af9..0fc0aaffb1 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImpl.java
@@ -2,6 +2,8 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 
 import org.apache.commons.collections4.CollectionUtils;
+import org.openecomp.core.util.UniqueValueUtil;
+import org.openecomp.core.utilities.json.JsonSchemaDataGenerator;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
@@ -12,7 +14,7 @@ import org.openecomp.sdc.logging.types.LoggerConstants;
 import org.openecomp.sdc.logging.types.LoggerErrorCode;
 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
 import org.openecomp.sdc.vendorsoftwareproduct.ComputeManager;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
+import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
@@ -51,33 +53,22 @@ public class ComputeManagerImpl implements ComputeManager {
   private CompositionEntityDataManager compositionEntityDataManager;
   private VendorSoftwareProductInfoDao vspInfoDao;
   private DeploymentFlavorDao deploymentFlavorDao;
-  private ComponentDao componentDao;
-  private static final String MANUAL = "Manual";
-
-  public ComputeManagerImpl(
-      VendorSoftwareProductInfoDao vspInfoDao,
-      ComputeDao computeDao,
-      CompositionEntityDataManager compositionEntityDataManager,
-      DeploymentFlavorDao deploymentFlavorDao,
-      ComponentDao componentDao
-     ) {
+
+  public ComputeManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
+                            ComputeDao computeDao,
+                            CompositionEntityDataManager compositionEntityDataManager,
+                            DeploymentFlavorDao deploymentFlavorDao) {
     this.computeDao = computeDao;
     this.compositionEntityDataManager = compositionEntityDataManager;
     this.vspInfoDao = vspInfoDao;
     this.deploymentFlavorDao = deploymentFlavorDao;
-    this.componentDao = componentDao;
   }
 
   @Override
-  public ComputeEntity createCompute(ComputeEntity compute, String user) {
-    ComputeEntity createdCompute = null;
-    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", compute.getVspId(),
-        compute.getComponentId());
-
-    /*Version activeVersion =
-        getVersionInfo(compute.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
-    compute.setVersion(activeVersion);*/
-    //if (!isManual(compute.getVspId(), activeVersion)) {
+  public ComputeEntity createCompute(ComputeEntity compute) {
+    mdcDataDebugMessage
+        .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId());
+
     if (!vspInfoDao.isManual(compute.getVspId(), compute.getVersion())) {
       ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
           .getAddComputeNotSupportedHeatOnboardMethodErrorBuilder();
@@ -87,92 +78,45 @@ public class ComputeManagerImpl implements ComputeManager {
           onboardingMethodUpdateErrorCode.message());
       throw new CoreException(onboardingMethodUpdateErrorCode);
     } else {
-
-      //validateComponentId(compute.getVspId(),compute.getVersion(),compute.getComponentId());
-        Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
-                (),compute.getComponentId());
-
-        validateVfcCompute(compute, vfcComputeList, LoggerTragetServiceName.CREATE_COMPUTE);
-        createdCompute = createCompute(compute);
+      validateUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+          compute.getComputeCompositionData().getName());
+
+      compute.setQuestionnaireData(
+          new JsonSchemaDataGenerator(getComputeQuestionnaireSchema(null)).generateData());
+      computeDao.create(compute);
+      createUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+          compute.getComputeCompositionData().getName());
     }
 
     mdcDataDebugMessage
         .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId());
 
-    return createdCompute;
+    return compute;
   }
 
-  private ComputeEntity createCompute(ComputeEntity compute) {
-
-    return compositionEntityDataManager.createCompute(compute);
-  }
-
-  /*private void validateCompute(ComputeEntity compute) {
-    Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
-        (),compute.getComponentId());
-
-    if (!isComputeNameUnique(vfcComputeList,compute.getComputeCompositionData().getName())) {
-      final ErrorCode duplicateComputeInComponentErrorBuilder =
-          new DuplicateComputeInComponentErrorBuilder(compute.getComputeCompositionData().getName(),
-              compute.getComponentId()).build();
-      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-          LoggerTragetServiceName.CREATE_COMPUTE, ErrorLevel.ERROR.name(),
-          LoggerErrorCode.DATA_ERROR.getErrorCode(),
-          duplicateComputeInComponentErrorBuilder.message());
-      throw new CoreException(duplicateComputeInComponentErrorBuilder);
-    }
-
-  }*/
-
-  private void validateComputeUpdate(ComputeEntity compute) {
-    Collection<ComputeEntity> vfcComputeList = listCompute(compute.getVspId(),compute.getVersion
-        (),compute.getComponentId());
-
-    for (ComputeEntity ce : vfcComputeList) {
-      if (ce.getId().equals(compute.getId())) {
-        vfcComputeList.remove(ce);
-        break;
-      }
-    }
-
-    if (!isComputeNameUnique(vfcComputeList,compute.getComputeCompositionData().getName())) {
-      final ErrorCode duplicateComputeInComponentErrorBuilder =
-          new DuplicateComputeInComponentErrorBuilder(compute.getComputeCompositionData().getName(),
-              compute.getComponentId()).build();
-      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-          LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
-          LoggerErrorCode.DATA_ERROR.getErrorCode(),
-          duplicateComputeInComponentErrorBuilder.message());
-      throw new CoreException(duplicateComputeInComponentErrorBuilder);
-    }
-
-  }
 
   @Override
-  public Collection<ListComputeResponse> listCompute(String vspId, Version version,
-                                                     String componentId, String user) {
-
+  public Collection<ListComputeResponse> listComputes(String vspId, Version version,
+                                                      String componentId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
-    //validateComponentId(vspId, version, componentId);
-    ComputeEntity entity = new ComputeEntity(vspId, version, componentId, null);
-    Collection<ComputeEntity> computes = computeDao.list(entity);
+    Collection<ComputeEntity> computes =
+        computeDao.list(new ComputeEntity(vspId, version, componentId, null));
 
     Collection<ListComputeResponse> computeResponse =
-        getListComputeResponse(vspId, version, user, computes);
+        getListComputeResponse(vspId, version, computes);
     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 
     return computeResponse;
   }
 
   private Collection<ListComputeResponse> getListComputeResponse(String vspId, Version version,
-                                                                 String user,
                                                                  Collection<ComputeEntity> computes) {
-    Set<String> vspComputes = getComputeAssociatedWithDepFlavors(vspId, version, user);
-    Collection<ListComputeResponse> computeResponse = new ArrayList<ListComputeResponse>();
-    for(ComputeEntity computeEntity : computes) {
+    Set<String> vspComputes = getComputeAssociatedWithDepFlavors(vspId, version);
+    Collection<ListComputeResponse> computeResponse = new ArrayList<>();
+    for (ComputeEntity computeEntity : computes) {
       ListComputeResponse response = new ListComputeResponse();
       response.setComputeEntity(computeEntity);
-      if(vspComputes.contains(computeEntity.getId())) {
+      if (vspComputes.contains(computeEntity.getId())) {
         response.setAssociatedWithDeploymentFlavor(true);
       } else {
         response.setAssociatedWithDeploymentFlavor(false);
@@ -182,16 +126,15 @@ public class ComputeManagerImpl implements ComputeManager {
     return computeResponse;
   }
 
-  private Set<String> getComputeAssociatedWithDepFlavors(String vspId, Version version,
-                                                         String user) {
+  private Set<String> getComputeAssociatedWithDepFlavors(String vspId, Version version) {
     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
         deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
-    Set<String> vspComputes = new HashSet<String>();
-    for(DeploymentFlavorEntity entity : deploymentFlavorEntities) {
+    Set<String> vspComputes = new HashSet<>();
+    for (DeploymentFlavorEntity entity : deploymentFlavorEntities) {
       final List<ComponentComputeAssociation> componentComputeAssociations =
           entity.getDeploymentFlavorCompositionData().getComponentComputeAssociations();
-      if(componentComputeAssociations != null  && !componentComputeAssociations.isEmpty()) {
-        for(ComponentComputeAssociation association : componentComputeAssociations) {
+      if (componentComputeAssociations != null && !componentComputeAssociations.isEmpty()) {
+        for (ComponentComputeAssociation association : componentComputeAssociations) {
           vspComputes.add(association.getComputeFlavorId());
         }
       }
@@ -199,32 +142,14 @@ public class ComputeManagerImpl implements ComputeManager {
     return vspComputes;
   }
 
-  private boolean isComputeNameUnique(Collection<ComputeEntity> vfcComputeList, String name) {
-    for (ComputeEntity compute : vfcComputeList) {
-      if (compute.getComputeCompositionData().getName().equalsIgnoreCase(name)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  private Collection<ComputeEntity> listCompute(String vspId, Version version,String componentId) {
-    Collection<ComputeEntity> computeEntities =
-        computeDao.list(new ComputeEntity(vspId, version, componentId, null));
-
-    return computeEntities;
-  }
-
   @Override
   public CompositionEntityResponse<ComputeData> getCompute(String vspId, Version version,
                                                            String componentId,
-                                                           String computeFlavorId, String user) {
+                                                           String computeFlavorId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
         componentId, computeFlavorId);
 
-    /*version = VersioningUtil
-        .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
-    ComputeEntity computeEntity = getCompute(vspId, version, componentId, computeFlavorId);
+    ComputeEntity computeEntity = getValidatedCompute(vspId, version, componentId, computeFlavorId);
     ComputeData compute = computeEntity.getComputeCompositionData();
 
     ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
@@ -242,9 +167,8 @@ public class ComputeManagerImpl implements ComputeManager {
     return response;
   }
 
-  private ComputeEntity getCompute(String vspId, Version version, String componentId, String
-      computeFlavorId) {
-    //validateComponentId(vspId,version,componentId);
+  private ComputeEntity getValidatedCompute(String vspId, Version version, String componentId,
+                                            String computeFlavorId) {
     ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId, version, componentId,
         computeFlavorId));
     VersioningUtil
@@ -253,186 +177,113 @@ public class ComputeManagerImpl implements ComputeManager {
     return retrieved;
   }
 
-  /*private void validateComponentId(String vspId, Version version, String componentId) {
-    ComponentEntity retrivedComponent = componentDao.get(new ComponentEntity(vspId, version,
-        componentId));
-    VersioningUtil
-        .validateEntityExistence(retrivedComponent, new ComponentEntity(vspId, version,
-            componentId),VspDetails.ENTITY_TYPE);
-  }*/
-
   @Override
   public QuestionnaireResponse getComputeQuestionnaire(String vspId, Version version, String
-          componentId, String computeId, String user) {
+      componentId, String computeId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, componentId", vspId, componentId, computeId);
 
-    /*version = VersioningUtil
-        .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
-    //validateComponentId(vspId,version,componentId);
     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
-    //validateComponentId(vspId,version,componentId);
-    ComputeEntity computeQuestionnaire = computeDao.getQuestionnaireData(vspId, version, componentId, computeId);
+    ComputeEntity computeQuestionnaire =
+        computeDao.getQuestionnaireData(vspId, version, componentId, computeId);
     VersioningUtil
-            .validateEntityExistence(computeQuestionnaire, new ComputeEntity(vspId, version, componentId,
-                    computeId), VspDetails.ENTITY_TYPE);
+        .validateEntityExistence(computeQuestionnaire,
+            new ComputeEntity(vspId, version, componentId, computeId), VspDetails.ENTITY_TYPE);
     questionnaireResponse.setData(computeQuestionnaire.getQuestionnaireData());
     questionnaireResponse.setSchema(getComputeQuestionnaireSchema(null));
 
-    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId,
-            componentId, computeId);
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId, computeId);
 
     return questionnaireResponse;
   }
 
 
-  protected String getComputeQuestionnaireSchema(SchemaTemplateInput schemaInput) {
-    mdcDataDebugMessage.debugEntryMessage(null, null);
-
-    mdcDataDebugMessage.debugExitMessage(null, null);
-    return SchemaGenerator
-        .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute,
-            schemaInput);
-  }
-
-
   @Override
-  public void updateComputeQuestionnaire(String vspId, Version version, String componentId, String
-      computeId,
-                                         String questionnaireData, String user) {
-    mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
-        componentId, computeId);
+  public void updateComputeQuestionnaire(String vspId, Version version, String componentId,
+                                         String computeId, String questionnaireData) {
+    mdcDataDebugMessage
+        .debugEntryMessage("VSP id, component id, compute id", vspId, componentId, computeId);
 
-    /*Version activeVersion =
-        getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();
-    getComponent(vspId, activeVersion, componentId);*/
-    ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId,version,componentId,
+    ComputeEntity retrieved = computeDao.get(new ComputeEntity(vspId, version, componentId,
         computeId));
     VersioningUtil.validateEntityExistence(retrieved, new ComputeEntity(vspId, version,
         componentId, computeId), VspDetails.ENTITY_TYPE);
 
     computeDao.updateQuestionnaireData(vspId, version, componentId, computeId, questionnaireData);
 
-    mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
-        componentId, computeId);
+    mdcDataDebugMessage
+        .debugExitMessage("VSP id, component id, compute id", vspId, componentId, computeId);
   }
 
   @Override
-  public CompositionEntityValidationData updateCompute(ComputeEntity compute, String user) {
+  public CompositionEntityValidationData updateCompute(ComputeEntity compute) {
     mdcDataDebugMessage
-            .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
-                    compute.getId());
-
-    /*Version activeVersion =
-        getVersionInfo(image.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
-    image.setVersion(activeVersion);*/
+        .debugEntryMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
+            compute.getId());
 
-    ComputeEntity retrieved = getComputeEntity(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+    ComputeEntity retrieved =
+        getComputeEntity(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
             compute.getId());
 
-    if(!vspInfoDao.isManual(compute.getVspId(), compute.getVersion())) {
-      final ComputeData computeCompositionData = compute.getComputeCompositionData();
-      final String name = computeCompositionData.getName();
-      //final String format = computeCompositionData.getFormat();
-      validateHeatVspComputeUpdate("Name", name, retrieved.getComputeCompositionData()
-              .getName());
-      /*validateHeatVspComputeUpdate("format", format, retrieved.getComputeCompositionData()
-          .getFormat());*/
+    boolean manual = vspInfoDao.isManual(compute.getVspId(), compute.getVersion());
+    if (!manual) {
+      validateHeatVspComputeUpdate("Name",
+          compute.getComputeCompositionData().getName(),
+          retrieved.getComputeCompositionData().getName());
     }
 
-    Collection<ComputeEntity> vfcComputeList = listComputes(compute.getVspId() ,
-            compute.getVersion(), compute.getComponentId());
-
-    //Set to null so that retrieved object is equal to one in list and gets removed.
-    retrieved.setQuestionnaireData(null);
-    vfcComputeList.remove(retrieved);
-    if(vspInfoDao.isManual(compute.getVspId(), compute.getVersion()))
-      validateVfcCompute(compute, vfcComputeList, LoggerTragetServiceName.UPDATE_COMPUTE);
-
-    //Set format to default value in order to handle FTL validation when compute format is null
-    /*if(compute.getComputeCompositionData().getFormat() == null)
-      compute.getComputeCompositionData().setFormat(ComputeFormat.qcow2.name());*/
-
     ComputeCompositionSchemaInput schemaInput = new ComputeCompositionSchemaInput();
     schemaInput.setCompute(compute.getComputeCompositionData());
 
     CompositionEntityValidationData validationData = compositionEntityDataManager
-            .validateEntity(compute, SchemaTemplateContext.composition, schemaInput);
+        .validateEntity(compute, SchemaTemplateContext.composition, schemaInput);
     if (CollectionUtils.isEmpty(validationData.getErrors())) {
+      updateUniqueName(compute.getVspId(), compute.getVersion(), compute.getComponentId(),
+          retrieved.getComputeCompositionData().getName(),
+          compute.getComputeCompositionData().getName());
       computeDao.update(compute);
     }
 
     mdcDataDebugMessage
-            .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
-                    compute.getId());
+        .debugExitMessage("VSP id, component id", compute.getVspId(), compute.getComponentId(),
+            compute.getId());
 
     return validationData;
   }
 
   private void validateHeatVspComputeUpdate(String name, String value, String retrivedValue) {
 
-    if(value != null && !value.equals(retrivedValue)) {
+    if (value != null && !value.equals(retrivedValue)) {
 
       final ErrorCode updateHeatComputeErrorBuilder =
-              DuplicateComputeInComponentErrorBuilder.getComputeHeatReadOnlyErrorBuilder(name);
+          DuplicateComputeInComponentErrorBuilder.getComputeHeatReadOnlyErrorBuilder(name);
 
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
-              LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
-              updateHeatComputeErrorBuilder.message());
+          LoggerTragetServiceName.UPDATE_COMPUTE, ErrorLevel.ERROR.name(),
+          LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
+          updateHeatComputeErrorBuilder.message());
       throw new CoreException(updateHeatComputeErrorBuilder);
     }
   }
 
-  private void validateVfcCompute(ComputeEntity compute, Collection<ComputeEntity> vfcComputeList,
-                                  String event) {
-    if (isComputeNameDuplicate(vfcComputeList,compute.getComputeCompositionData().getName(),
-        compute.getId())) {
-      ErrorCode errorCode = DuplicateComputeInComponentErrorBuilder
-          .getDuplicateComputeNameErrorBuilder(compute.getComputeCompositionData().getName(),
-              compute.getComponentId());
-
-      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-          event, ErrorLevel.ERROR.name(),
-          errorCode.id(),errorCode.message());
-
-      throw new CoreException(errorCode);
-    }
-  }
-
-  private boolean isComputeNameDuplicate(Collection<ComputeEntity> computes, String name, String computeId) {
-    for (ComputeEntity compute : computes) {
-      if (compute.getComputeCompositionData().getName().equalsIgnoreCase(name) && !compute.getId().equals(computeId)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-
   private ComputeEntity getComputeEntity(String vspId, Version version, String componentId,
-  String computeId) {
-      //validateComponentId(vspId,version,componentId);
-      ComputeEntity computeEntity = computeDao.get(new ComputeEntity(vspId, version, componentId, computeId));
-      VersioningUtil.validateEntityExistence(computeEntity, new ComputeEntity(vspId, version, componentId,
-      computeId), VspDetails.ENTITY_TYPE);
-      return computeEntity;
-      }
-
-  private Collection<ComputeEntity> listComputes(String vspId, Version version, String componentId) {
-    return computeDao.list(new ComputeEntity(vspId, version, componentId, null));
+                                         String computeId) {
+    ComputeEntity computeEntity =
+        computeDao.get(new ComputeEntity(vspId, version, componentId, computeId));
+    VersioningUtil
+        .validateEntityExistence(computeEntity, new ComputeEntity(vspId, version, componentId,
+            computeId), VspDetails.ENTITY_TYPE);
+    return computeEntity;
   }
 
   @Override
-  public void deleteCompute(String vspId, Version version, String componentId, String
-      computeFlavorId, String user) {
+  public void deleteCompute(String vspId, Version version, String componentId,
+                            String computeFlavorId) {
     final String VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG =
         "Composition entities may not be created / deleted for Vendor Software Product "
             + "whose entities were uploaded";
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, compute id", vspId,
         componentId, computeFlavorId);
 
-    /*Version activeVersion =
-        getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();*/
     if (!vspInfoDao.isManual(vspId, version)) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.DELETE_COMPUTE, ErrorLevel.ERROR.name(),
@@ -442,30 +293,32 @@ public class ComputeManagerImpl implements ComputeManager {
               .withId(VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED)
               .withMessage(VSP_COMPOSITION_EDIT_NOT_ALLOWED_MSG).build());
     }
-    ComputeEntity retrived = getCompute(vspId,version,componentId,computeFlavorId);
-    if (retrived != null){
-      deleteComputeFromDeploymentFlavors(vspId,version,computeFlavorId);
+    ComputeEntity retrieved = getValidatedCompute(vspId, version, componentId, computeFlavorId);
+    if (retrieved != null) {
+      deleteComputeFromDeploymentFlavors(vspId, version, computeFlavorId);
       computeDao.delete(new ComputeEntity(vspId, version, componentId, computeFlavorId));
+      deleteUniqueValue(retrieved.getVspId(), retrieved.getVersion(), retrieved.getComponentId(),
+          retrieved.getComputeCompositionData().getName());
     }
 
     mdcDataDebugMessage.debugExitMessage("VSP id, component id, compute id", vspId,
         componentId, computeFlavorId);
   }
 
-  private void deleteComputeFromDeploymentFlavors(String vspId, Version activeVersion,
+  private void deleteComputeFromDeploymentFlavors(String vspId, Version version,
                                                   String computeFlavorId) {
-    //Collection<DeploymentFlavorEntity> listDF = listDeploymentFlavors(vspId, activeVersion);
-    Collection<DeploymentFlavorEntity> listDF = deploymentFlavorDao.list(new DeploymentFlavorEntity
-        (vspId, activeVersion, null));
-    for(DeploymentFlavorEntity df : listDF) {
-      DeploymentFlavorEntity deploymentFlavorEntity=removeComputeFromDF(df, computeFlavorId);
-      if(deploymentFlavorEntity!=null)
+    Collection<DeploymentFlavorEntity> listDF =
+        deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
+    for (DeploymentFlavorEntity df : listDF) {
+      DeploymentFlavorEntity deploymentFlavorEntity = removeComputeFromDF(df, computeFlavorId);
+      if (deploymentFlavorEntity != null) {
         deploymentFlavorDao.update(deploymentFlavorEntity);
+      }
     }
   }
 
-  private DeploymentFlavorEntity removeComputeFromDF(DeploymentFlavorEntity df, String
-      computeFlavorId) {
+  private DeploymentFlavorEntity removeComputeFromDF(DeploymentFlavorEntity df,
+                                                     String computeFlavorId) {
     DeploymentFlavor flavor = df.getDeploymentFlavorCompositionData();
     List<ComponentComputeAssociation> associations = flavor.getComponentComputeAssociations();
     if (associations != null) {
@@ -486,20 +339,47 @@ public class ComputeManagerImpl implements ComputeManager {
     return null;
   }
 
-  protected String getComputeCompositionSchema(SchemaTemplateInput schemaInput){
-    mdcDataDebugMessage.debugEntryMessage(null, null);
-    mdcDataDebugMessage.debugExitMessage(null, null);
-    return SchemaGenerator.generate(SchemaTemplateContext.composition, CompositionEntityType.compute, schemaInput);
+  protected String getComputeCompositionSchema(SchemaTemplateInput schemaInput) {
+    mdcDataDebugMessage.debugEntryMessage(null);
+    mdcDataDebugMessage.debugExitMessage(null);
+    return SchemaGenerator
+        .generate(SchemaTemplateContext.composition, CompositionEntityType.compute, schemaInput);
+  }
+
+  protected String getComputeQuestionnaireSchema(SchemaTemplateInput schemaInput) {
+    mdcDataDebugMessage.debugEntryMessage(null);
+    mdcDataDebugMessage.debugExitMessage(null);
+    return SchemaGenerator
+        .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.compute, schemaInput);
   }
 
-   /*boolean isManual(String vspId, Version version) {
+  protected void validateUniqueName(String vspId, Version version, String componentId,
+                                    String name) {
+    UniqueValueUtil.validateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME,
+        vspId, version.getId(), componentId, name);
+  }
 
-    VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
-    String onboardingMethod = vsp.getOnboardingMethod();
-    if (MANUAL.equals(onboardingMethod)) {
-      return true;
-    }
-    return false;
-  }*/
+  protected void createUniqueName(String vspId, Version version, String componentId, String name) {
+    UniqueValueUtil
+        .createUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
+            version.getId(), componentId, name);
+  }
+
+  protected void updateUniqueName(String vspId, Version version, String componentId,
+                                  String oldName, String newName) {
+    UniqueValueUtil
+        .updateUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, oldName,
+            newName, vspId, version.getId(), componentId);
+  }
 
+  protected void deleteUniqueValue(String vspId, Version version, String componentId, String name) {
+    if (componentId == null) {
+      UniqueValueUtil
+          .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
+              version.getId(), name);
+    }
+    UniqueValueUtil
+        .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.COMPUTE_NAME, vspId,
+            version.getId(), componentId, name);
+  }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImpl.java
index 0873eaf921..f1acaae178 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImpl.java
@@ -44,18 +44,14 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
   private VendorSoftwareProductInfoDao vspInfoDao;
   private DeploymentFlavorDao deploymentFlavorDao;
   private CompositionEntityDataManager compositionEntityDataManager;
-  private  ComponentDao componentDao;
+  private ComponentDao componentDao;
   private ComputeDao computeDao;
 
-  public DeploymentFlavorManagerImpl(
-      VendorSoftwareProductInfoDao vspInfoDao,
-      DeploymentFlavorDao deploymentFlavorDao,
-      CompositionEntityDataManager compositionEntityDataManager,
-      ComponentDao componentDao,
-      ComputeDao computeDao
-
-  ) {
-
+  public DeploymentFlavorManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
+                                     DeploymentFlavorDao deploymentFlavorDao,
+                                     CompositionEntityDataManager compositionEntityDataManager,
+                                     ComponentDao componentDao,
+                                     ComputeDao computeDao) {
     this.vspInfoDao = vspInfoDao;
     this.deploymentFlavorDao = deploymentFlavorDao;
     this.compositionEntityDataManager = compositionEntityDataManager;
@@ -65,31 +61,17 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
   }
 
   @Override
-  public Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version,
-                                                                  String user) {
+  public Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
-    /*version = VersioningUtil
-        .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
-
     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-    return listDeploymentFlavors(vspId, version);
-  }
-
-  private Collection<DeploymentFlavorEntity> listDeploymentFlavors(String vspId, Version version) {
-    Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
-        deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
-    return deploymentFlavorEntities;
+    return deploymentFlavorDao.list(new DeploymentFlavorEntity(vspId, version, null));
   }
 
   @Override
   public DeploymentFlavorEntity createDeploymentFlavor(
-      DeploymentFlavorEntity deploymentFlavorEntity, String user) {
-    DeploymentFlavorEntity createDeploymentFlavor = null;
+      DeploymentFlavorEntity deploymentFlavorEntity) {
+    DeploymentFlavorEntity createDeploymentFlavor;
     mdcDataDebugMessage.debugEntryMessage("VSP id ", deploymentFlavorEntity.getVspId());
-    /*Version activeVersion =
-        getVersionInfo(deploymentFlavorEntity.getVspId(), VersionableEntityAction.Write, user)
-            .getActiveVersion();
-    deploymentFlavorEntity.setVersion(activeVersion);*/
 
     if (!vspInfoDao.isManual(deploymentFlavorEntity.getVspId(),
         deploymentFlavorEntity.getVersion())) {
@@ -100,31 +82,30 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), deploymentFlavorErrorBuilder.message());
       throw new CoreException(deploymentFlavorErrorBuilder);
     } else {
-      validateDeploymentFlavor(deploymentFlavorEntity, user, deploymentFlavorEntity.getVersion());
+      validateDeploymentFlavor(deploymentFlavorEntity, deploymentFlavorEntity.getVersion());
       createDeploymentFlavor =
           compositionEntityDataManager.createDeploymentFlavor(deploymentFlavorEntity);
     }
     return createDeploymentFlavor;
   }
 
-  private void validateDeploymentFlavor(DeploymentFlavorEntity deploymentFlavorEntity, String
-      user, Version activeVersion) {
-
+  private void validateDeploymentFlavor(DeploymentFlavorEntity deploymentFlavorEntity,
+                                        Version version) {
     //Validation for unique model.
     Collection<DeploymentFlavorEntity> listDeploymentFlavors =
         listDeploymentFlavors(deploymentFlavorEntity.getVspId(),
-            activeVersion);
+            version);
     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
 
     List<String> featureGroups =
-        getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(), user, activeVersion);
+        getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(), version);
     String featureGroup = deploymentFlavorEntity.getDeploymentFlavorCompositionData()
         .getFeatureGroupId();
-    if (featureGroup != null && featureGroup.trim().length()>0) {
+    if (featureGroup != null && featureGroup.trim().length() > 0) {
       if (isEmpty(featureGroups) || (!(validFeatureGroup(featureGroups, featureGroup)))) {
         ErrorCode deploymentFlavorErrorBuilder = DeploymentFlavorErrorBuilder
             .getFeatureGroupNotexistErrorBuilder(featureGroup, deploymentFlavorEntity.getVspId(),
-                activeVersion);
+                version);
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
             LoggerTragetServiceName.CREATE_DEPLOYMENT_FLAVOR, ErrorLevel.ERROR.name(),
             LoggerErrorCode.DATA_ERROR.getErrorCode(), deploymentFlavorErrorBuilder.message());
@@ -132,7 +113,7 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
       }
     }
 
-    validateComponentComputeAssociation(deploymentFlavorEntity, activeVersion);
+    validateComponentComputeAssociation(deploymentFlavorEntity, version);
   }
 
   private void isDeploymentFlavorModelDuplicate(DeploymentFlavorEntity deploymentFlavorEntity,
@@ -152,14 +133,8 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
     });
   }
 
-  private List<String> getFeatureGroupListForVsp(String vspId,
-                                                 String user, Version activeVersion) {
-    /*VersionedVendorSoftwareProductInfo versionedVendorSoftwareProductInfo = getVspDetails(
-        vspId,activeVersion, user);
-    return versionedVendorSoftwareProductInfo.getVspDetails()
-        .getFeatureGroups();*/
-
-    final VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, activeVersion));
+  private List<String> getFeatureGroupListForVsp(String vspId, Version version) {
+    final VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
     return vspDetails.getFeatureGroups();
   }
 
@@ -183,7 +158,7 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
   }
 
   private void validateComponentComputeAssociation(DeploymentFlavorEntity deploymentFlavorEntity,
-                                                   Version activeVersion) {
+                                                   Version version) {
     List<ComponentComputeAssociation> componentComputeAssociationList = deploymentFlavorEntity
         .getDeploymentFlavorCompositionData().getComponentComputeAssociations();
     List<String> vfcList = new ArrayList<>();
@@ -201,14 +176,14 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
               LoggerErrorCode.DATA_ERROR.getErrorCode(), invalidAssociationErrorBuilder.message());
           throw new CoreException(invalidAssociationErrorBuilder);
         } else if (componentComputeAssociation.getComponentId() != null &&
-            componentComputeAssociation.getComponentId().trim().length() > 0 ) {
-          ComponentEntity component = getComponent(deploymentFlavorEntity.getVspId(), activeVersion,
+            componentComputeAssociation.getComponentId().trim().length() > 0) {
+          ComponentEntity component = getComponent(deploymentFlavorEntity.getVspId(), version,
               componentComputeAssociation.getComponentId());
           if (componentComputeAssociation
               .getComputeFlavorId() != null && componentComputeAssociation
-              .getComputeFlavorId().trim().length() > 0 ) {
+              .getComputeFlavorId().trim().length() > 0) {
             ComputeEntity computeFlavor = computeDao.get(new ComputeEntity(deploymentFlavorEntity
-                    .getVspId(), activeVersion, componentComputeAssociation.getComponentId(),
+                .getVspId(), version, componentComputeAssociation.getComponentId(),
                 componentComputeAssociation.getComputeFlavorId()));
             if (computeFlavor == null) {
               ErrorCode invalidComputeIdErrorBuilder = DeploymentFlavorErrorBuilder
@@ -251,22 +226,19 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
   @Override
   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavor(String vspId,
                                                                          Version version,
-                                                                         String deploymentFlavorId,
-                                                                         String user) {
+                                                                         String deploymentFlavorId) {
     mdcDataDebugMessage
         .debugEntryMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
 
-    /*version = VersioningUtil
-        .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
-    DeploymentFlavorEntity deploymentFlavorEntity = getDeploymentFlavor(vspId,version,
-        deploymentFlavorId);
+    DeploymentFlavorEntity deploymentFlavorEntity =
+        getValidatedDeploymentFlavor(vspId, version, deploymentFlavorId);
     DeploymentFlavor deploymentFlavor = deploymentFlavorEntity.getDeploymentFlavorCompositionData();
     DeploymentFlavorCompositionSchemaInput schemaInput = new
         DeploymentFlavorCompositionSchemaInput();
     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
     schemaInput.setDeploymentFlavor(deploymentFlavor);
     List<String> featureGroups =
-        getFeatureGroupListForVsp(vspId, user, version);
+        getFeatureGroupListForVsp(vspId, version);
     schemaInput.setFeatureGroupIds(featureGroups);
     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
     response.setId(deploymentFlavorId);
@@ -280,27 +252,24 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
     return response;
   }
 
-  private DeploymentFlavorEntity getDeploymentFlavor(String vspId, Version version, String
+  private DeploymentFlavorEntity getValidatedDeploymentFlavor(String vspId, Version version, String
       deploymentFlavorId) {
     DeploymentFlavorEntity retrieved = deploymentFlavorDao.get(new DeploymentFlavorEntity(vspId,
         version, deploymentFlavorId));
     VersioningUtil
         .validateEntityExistence(retrieved, new DeploymentFlavorEntity(vspId, version,
-            deploymentFlavorId ), VspDetails.ENTITY_TYPE);
+            deploymentFlavorId), VspDetails.ENTITY_TYPE);
     return retrieved;
   }
 
   @Override
   public CompositionEntityResponse<DeploymentFlavor> getDeploymentFlavorSchema(String vspId,
-                                                                               Version version,
-                                                                               String user) {
-    /*version = VersioningUtil
-        .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
-    DeploymentFlavorCompositionSchemaInput schemaInput= new
-        DeploymentFlavorCompositionSchemaInput();
+                                                                               Version version) {
+    DeploymentFlavorCompositionSchemaInput schemaInput =
+        new DeploymentFlavorCompositionSchemaInput();
     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
     List<String> featureGroups =
-        getFeatureGroupListForVsp(vspId, user, version);
+        getFeatureGroupListForVsp(vspId, version);
     schemaInput.setFeatureGroupIds(featureGroups);
     CompositionEntityResponse<DeploymentFlavor> response = new CompositionEntityResponse<>();
     response.setSchema((SchemaGenerator
@@ -310,14 +279,13 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
   }
 
   @Override
-  public void deleteDeploymentFlavor(String vspId, Version version, String deploymentFlavorId,
-                                     String user) {
+  public void deleteDeploymentFlavor(String vspId, Version version, String deploymentFlavorId) {
     mdcDataDebugMessage
         .debugEntryMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
     /*Version activeVersion =
         getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();*/
-    DeploymentFlavorEntity deploymentFlavorEntity = getDeploymentFlavor(vspId,version,
-        deploymentFlavorId);
+    DeploymentFlavorEntity deploymentFlavorEntity =
+        getValidatedDeploymentFlavor(vspId, version, deploymentFlavorId);
     if (!vspInfoDao.isManual(vspId, version)) {
       final ErrorCode deleteDeploymentFlavorErrorBuilder =
           NotSupportedHeatOnboardMethodErrorBuilder
@@ -328,7 +296,7 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
           deleteDeploymentFlavorErrorBuilder.message());
       throw new CoreException(deleteDeploymentFlavorErrorBuilder);
     }
-    if(deploymentFlavorEntity != null) {
+    if (deploymentFlavorEntity != null) {
       deploymentFlavorDao.delete(new DeploymentFlavorEntity(vspId, version, deploymentFlavorId));
 
     }
@@ -336,8 +304,8 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
         .debugExitMessage("VSP id, deployment flavor id", vspId, deploymentFlavorId);
   }
 
-  public CompositionEntityValidationData updateDeploymentFlavor(DeploymentFlavorEntity
-                                                                    deploymentFlavorEntity, String user) {
+  public CompositionEntityValidationData updateDeploymentFlavor(
+      DeploymentFlavorEntity deploymentFlavorEntity) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, deploymentFlavor id", deploymentFlavorEntity
         .getVspId(), deploymentFlavorEntity.getId());
     /*Version activeVersion =
@@ -355,9 +323,9 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
           updateDeploymentFlavorErrorBuilder.message());
       throw new CoreException(updateDeploymentFlavorErrorBuilder);
     }
-    //deploymentFlavorEntity.setVersion(activeVersion);
     DeploymentFlavorEntity retrieved =
-        getDeploymentFlavor(deploymentFlavorEntity.getVspId(), deploymentFlavorEntity.getVersion(),
+        getValidatedDeploymentFlavor(deploymentFlavorEntity.getVspId(),
+            deploymentFlavorEntity.getVersion(),
             deploymentFlavorEntity.getId());
 
 
@@ -367,7 +335,8 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
     isDeploymentFlavorModelDuplicate(deploymentFlavorEntity, listDeploymentFlavors);
 
     //validateComponentComputeAssociation(deploymentFlavorEntity, activeVersion);
-    validateComponentComputeAssociation(deploymentFlavorEntity, deploymentFlavorEntity.getVersion());
+    validateComponentComputeAssociation(deploymentFlavorEntity,
+        deploymentFlavorEntity.getVersion());
 
     DeploymentFlavorCompositionSchemaInput schemaInput = new
         DeploymentFlavorCompositionSchemaInput();
@@ -376,7 +345,7 @@ public class DeploymentFlavorManagerImpl implements DeploymentFlavorManager {
     schemaInput.setDeploymentFlavor(retrieved.getDeploymentFlavorCompositionData());
 
     List<String> featureGroups =
-        getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(), user,
+        getFeatureGroupListForVsp(deploymentFlavorEntity.getVspId(),
             deploymentFlavorEntity.getVersion());
     schemaInput.setFeatureGroupIds(featureGroups);
 
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImpl.java
index 82b71399aa..0429ba4de8 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImpl.java
@@ -37,72 +37,49 @@ import org.openecomp.sdc.versioning.dao.types.Version;
 import java.util.Collection;
 import java.util.stream.Collectors;
 
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
-
 public class ImageManagerImpl implements ImageManager {
   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
   private VendorSoftwareProductInfoDao vspInfoDao;
   private ImageDao imageDao;
   private CompositionEntityDataManager compositionEntityDataManager;
 
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
-
-  public ImageManagerImpl(
-          VendorSoftwareProductInfoDao vspInfoDao,
-          ImageDao imageDao,
-          CompositionEntityDataManager compositionEntityDataManager
-
-  ) {
-
+  public ImageManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
+                          ImageDao imageDao,
+                          CompositionEntityDataManager compositionEntityDataManager) {
     this.vspInfoDao = vspInfoDao;
     this.imageDao = imageDao;
     this.compositionEntityDataManager = compositionEntityDataManager;
-
   }
 
   @Override
-  public ImageEntity createImage(ImageEntity imageEntity, String user) {
-    /*Version activeVersion = getVersionInfo(imageEntity.getVspId(),
-        VersionableEntityAction.Write, user).getActiveVersion();
-
-    imageEntity.setVersion(activeVersion);*/
+  public ImageEntity createImage(ImageEntity imageEntity) {
     boolean isManual = vspInfoDao.isManual(imageEntity.getVspId(), imageEntity.getVersion());
     if (!isManual) {
-
       ErrorCode errorCode = NotSupportedHeatOnboardMethodErrorBuilder
-              .getAddImageNotSupportedHeatOnboardMethodErrorBuilder();
+          .getAddImageNotSupportedHeatOnboardMethodErrorBuilder();
 
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.CREATE_IMAGE, ErrorLevel.ERROR.name(),
-              errorCode.id(), errorCode.message());
+          LoggerTragetServiceName.CREATE_IMAGE, ErrorLevel.ERROR.name(),
+          errorCode.id(), errorCode.message());
 
       throw new CoreException(errorCode);
     }
-
-    /*Collection<ImageEntity> vfcImageList = listImages(imageEntity.getVspId() ,
-        imageEntity.getVersion(), imageEntity.getComponentId());*/
     compositionEntityDataManager.createImage(imageEntity);
     return imageEntity;
   }
 
   @Override
-  public Collection<ImageEntity> listImages(String vspId, Version version, String componentId,
-                                            String user) {
+  public Collection<ImageEntity> listImages(String vspId, Version version, String componentId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
-    Collection<ImageEntity> imageEntities = listImages(vspId, version, componentId);
+    Collection<ImageEntity> imageEntities =
+        imageDao.list(new ImageEntity(vspId, version, componentId, null));
 
     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-
     return imageEntities;
   }
 
-  private Collection<ImageEntity> listImages(String vspId, Version version, String componentId) {
-    return imageDao.list(new ImageEntity(vspId, version, componentId, null));
-  }
-
   @Override
-  public CompositionEntityResponse getImageSchema(String vspId, String user) {
+  public CompositionEntityResponse<Image> getImageSchema(String vspId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, image id", vspId);
 
     CompositionEntityResponse<Image> response = new CompositionEntityResponse<>();
@@ -118,14 +95,10 @@ public class ImageManagerImpl implements ImageManager {
 
   @Override
   public CompositionEntityResponse<Image> getImage(String vspId, Version version, String
-          componentId, String imageId, String user) {
+      componentId, String imageId) {
 
     mdcDataDebugMessage.debugEntryMessage("VSP id, componentId, image id", vspId, componentId,
-            imageId);
-
-    /*version = VersioningUtil
-        .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));*/
-
+        imageId);
     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
 
     Image image = imageEntity.getImageCompositionData();
@@ -142,25 +115,21 @@ public class ImageManagerImpl implements ImageManager {
     response.setSchema(getImageCompositionSchema(schemaInput));
 
     mdcDataDebugMessage.debugExitMessage("VSP id, componentId, image id", vspId, componentId,
-            imageId);
+        imageId);
 
     return response;
   }
 
   @Override
   public QuestionnaireResponse getImageQuestionnaire(String vspId, Version version, String
-          componentId, String imageId, String user) {
+      componentId, String imageId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
-
-    /*version = VersioningUtil
-        .resolveVersion(version, getVersionInfo(vspId, VersionableEntityAction.Read, user));
-    validateComponentId(vspId,version,componentId);*/
     QuestionnaireResponse questionnaireResponse = new QuestionnaireResponse();
     //validateComponentId(vspId,version,componentId);
 
     ImageEntity retrieved = imageDao.getQuestionnaireData(vspId, version, componentId, imageId);
     VersioningUtil.validateEntityExistence(retrieved, new ImageEntity(vspId, version, componentId,
-            imageId), ComponentEntity.ENTITY_TYPE);
+        imageId), ComponentEntity.ENTITY_TYPE);
     questionnaireResponse.setData(retrieved.getQuestionnaireData());
     questionnaireResponse.setSchema(getImageQuestionnaireSchema(null));
 
@@ -170,72 +139,63 @@ public class ImageManagerImpl implements ImageManager {
   }
 
   @Override
-  public void deleteImage(String vspId, Version version, String componentId, String imageId, String
-          user) {
+  public void deleteImage(String vspId, Version version, String componentId, String imageId) {
     mdcDataDebugMessage
-            .debugEntryMessage("VSP id, component id", vspId, componentId, imageId);
-
-    /*Version activeVersion =
-        getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();
-    ComponentEntity component = getComponent(vspId, activeVersion, componentId);*/
+        .debugEntryMessage("VSP id, component id", vspId, componentId, imageId);
     ImageEntity imageEntity = getImageEntity(vspId, version, componentId, imageId);
     if (!vspInfoDao.isManual(vspId, version)) {
       final ErrorCode deleteImageErrorBuilder =
-              NotSupportedHeatOnboardMethodErrorBuilder
-                      .getDelImageNotSupportedHeatOnboardMethodErrorBuilder();
+          NotSupportedHeatOnboardMethodErrorBuilder
+              .getDelImageNotSupportedHeatOnboardMethodErrorBuilder();
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.DELETE_IMAGE, ErrorLevel.ERROR.name(),
-              LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
-              deleteImageErrorBuilder.message());
+          LoggerTragetServiceName.DELETE_IMAGE, ErrorLevel.ERROR.name(),
+          LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
+          deleteImageErrorBuilder.message());
       throw new CoreException(deleteImageErrorBuilder);
     }
     if (imageEntity != null) {
       imageDao.delete(new ImageEntity(vspId, version, componentId, imageId));
     }
     mdcDataDebugMessage
-            .debugExitMessage("VSP id, component id", vspId, componentId, imageId);
+        .debugExitMessage("VSP id, component id", vspId, componentId, imageId);
   }
 
   private void validateHeatVspImageUpdate(String name, String value, String retrivedValue) {
-
-    if(value != null && !value.equals(retrivedValue)) {
-
+    if (value != null && !value.equals(retrivedValue)) {
       final ErrorCode updateHeatImageErrorBuilder =
-              ImageErrorBuilder.getImageHeatReadOnlyErrorBuilder(name);
+          ImageErrorBuilder.getImageHeatReadOnlyErrorBuilder(name);
 
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
-              LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
-              updateHeatImageErrorBuilder.message());
+          LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
+          LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
+          updateHeatImageErrorBuilder.message());
       throw new CoreException(updateHeatImageErrorBuilder);
     }
   }
 
   @Override
-  public CompositionEntityValidationData updateImage(ImageEntity image, String user) {
+  public CompositionEntityValidationData updateImage(ImageEntity image) {
     mdcDataDebugMessage
-            .debugEntryMessage("VSP id, component id", image.getVspId(), image.getComponentId(),
-                    image.getId());
+        .debugEntryMessage("VSP id, component id", image.getVspId(), image.getComponentId(),
+            image.getId());
 
-    /*Version activeVersion =
-        getVersionInfo(image.getVspId(), VersionableEntityAction.Write, user).getActiveVersion();
-    image.setVersion(activeVersion);*/
     boolean isManual = vspInfoDao.isManual(image.getVspId(), image.getVersion());
-    ImageEntity retrieved = getImageEntity(image.getVspId(), image.getVersion(), image.getComponentId(),
+    ImageEntity retrieved =
+        getImageEntity(image.getVspId(), image.getVersion(), image.getComponentId(),
             image.getId());
 
-    if(!isManual) {
+    if (!isManual) {
       final Image imageCompositionData = image.getImageCompositionData();
       final String fileName = imageCompositionData.getFileName();
       //final String format = imageCompositionData.getFormat();
       validateHeatVspImageUpdate("fileName", fileName, retrieved.getImageCompositionData()
-              .getFileName());
+          .getFileName());
       /*validateHeatVspImageUpdate("format", format, retrieved.getImageCompositionData()
           .getFormat());*/
     }
 
-    Collection<ImageEntity> vfcImageList = listImages(image.getVspId() ,
-            image.getVersion(), image.getComponentId());
+    Collection<ImageEntity> vfcImageList = listImages(image.getVspId(),
+        image.getVersion(), image.getComponentId());
 
     //Set to null so that retrieved object is equal to one in list and gets removed.
     retrieved.setQuestionnaireData(null);
@@ -249,50 +209,45 @@ public class ImageManagerImpl implements ImageManager {
     schemaInput.setImage(image.getImageCompositionData());
 
     CompositionEntityValidationData validationData = compositionEntityDataManager
-            .validateEntity(image, SchemaTemplateContext.composition, schemaInput);
+        .validateEntity(image, SchemaTemplateContext.composition, schemaInput);
     if (CollectionUtils.isEmpty(validationData.getErrors())) {
       imageDao.update(image);
     }
 
     mdcDataDebugMessage
-            .debugExitMessage("VSP id, component id", image.getVspId(), image.getComponentId(),
-                    image.getId());
+        .debugExitMessage("VSP id, component id", image.getVspId(), image.getComponentId(),
+            image.getId());
 
     return validationData;
   }
 
   @Override
   public void updateImageQuestionnaire(String vspId, Version version, String componentId, String
-          imageId, String questionnaireData, String user) {
+      imageId, String questionnaireData) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id, imageId", vspId, componentId,
-            imageId);
+        imageId);
 
     getImageEntity(vspId, version, componentId, imageId);
 
-    /*Version activeVersion =
-        getVersionInfo(vspId, VersionableEntityAction.Write, user).getActiveVersion();
-
-    getComponent(vspId, activeVersion, componentId);*/
 
     final ImageDetails image = JsonUtil.json2Object(questionnaireData, ImageDetails.class);
     final String format = image.getFormat();
     try {
       if (format != null) {
-        final ImageFormat imageFormat = ImageFormat.valueOf(format);
+        ImageFormat.valueOf(format);
       }
     } catch (IllegalArgumentException exception) {
-      log.debug("", exception);
       ErrorCode errorCode = ImageErrorBuilder.getInvalidImageFormatErrorBuilder();
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
-              errorCode.id(), errorCode.message() );
+          LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
+          errorCode.id(), errorCode.message());
       throw new CoreException(errorCode);
     }
 
     //Validate Format is read only for HEAT Onboarding
     if (!vspInfoDao.isManual(vspId, version)) {
       final QuestionnaireResponse imageQuestionnaire = getImageQuestionnaire(vspId, version,
-              componentId, imageId, user);
+          componentId, imageId);
       final String data = imageQuestionnaire.getData();
       if (data != null) {
         String retrivedFormat = JsonUtil.json2Object(data, ImageDetails.class).getFormat();
@@ -300,34 +255,33 @@ public class ImageManagerImpl implements ImageManager {
       }
     }
 
-    if(!isImageVersionUnique(vspId, version, componentId, imageId, image, user))
-    {
+    if (!isImageVersionUnique(vspId, version, componentId, imageId, image)) {
       ErrorCode errorCode = ImageErrorBuilder.getDuplicateImageVersionErrorBuilder(image
-              .getVersion(), componentId);
+          .getVersion(), componentId);
 
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-              LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
-              errorCode.id(),errorCode.message());
+          LoggerTragetServiceName.UPDATE_IMAGE, ErrorLevel.ERROR.name(),
+          errorCode.id(), errorCode.message());
 
       throw new CoreException(errorCode);
     }
 
     imageDao.updateQuestionnaireData(vspId, version, componentId, imageId, questionnaireData);
     mdcDataDebugMessage.debugExitMessage("VSP id, component id, imageId", vspId, componentId,
-            imageId);
+        imageId);
   }
 
-  private boolean isImageVersionUnique(String vspId, Version version, String componentId, String imageId,
-                                       ImageDetails image, String user)
-  {
+  private boolean isImageVersionUnique(String vspId, Version version, String componentId,
+                                       String imageId,
+                                       ImageDetails image) {
     boolean isPresent = true;
-    if(image!=null && image.getVersion()!=null)
-    {
-      Collection<ImageEntity> imageEntities = imageDao.list(new ImageEntity(vspId, version, componentId, null));
-      if(CollectionUtils.isNotEmpty(imageEntities))
-      {
-        imageEntities = imageEntities.stream().filter(imageEntity -> image.getVersion().trim().equalsIgnoreCase(
-                getImageVersion(vspId, version, componentId, imageEntity, user))
+    if (image != null && image.getVersion() != null) {
+      Collection<ImageEntity> imageEntities =
+          imageDao.list(new ImageEntity(vspId, version, componentId, null));
+      if (CollectionUtils.isNotEmpty(imageEntities)) {
+        imageEntities =
+            imageEntities.stream().filter(imageEntity -> image.getVersion().trim().equalsIgnoreCase(
+                getImageVersion(vspId, version, componentId, imageEntity))
                 && !imageEntity.getId().equals(imageId)).collect(Collectors.toList());
 
         isPresent = CollectionUtils.isEmpty(imageEntities);
@@ -337,14 +291,17 @@ public class ImageManagerImpl implements ImageManager {
     return isPresent;
   }
 
-  private String getImageVersion(String vspId, Version version, String componentId, ImageEntity imageEntity, String user)
-  {
+  private String getImageVersion(String vspId, Version version, String componentId,
+                                 ImageEntity imageEntity) {
     QuestionnaireResponse imageQuestionnaire = getImageQuestionnaire(vspId, version,
-            componentId, imageEntity.getId(), user);
-    ImageDetails imageDetails = JsonUtil.json2Object(imageQuestionnaire.getData(), ImageDetails.class);
+        componentId, imageEntity.getId());
+    ImageDetails imageDetails =
+        JsonUtil.json2Object(imageQuestionnaire.getData(), ImageDetails.class);
 
-    return imageDetails==null?null:imageDetails.getVersion()!=null?imageDetails.getVersion().trim():null;
+    return imageDetails == null ? null
+        : imageDetails.getVersion() != null ? imageDetails.getVersion().trim() : null;
   }
+
   private ImageEntity getImageEntity(String vspId, Version version, String componentId,
                                      String imageId) {
     //validateComponentId(vspId,version,componentId);
@@ -352,34 +309,24 @@ public class ImageManagerImpl implements ImageManager {
     ImageEntity imageEntity = imageDao.get(new ImageEntity(vspId, version, componentId, imageId));
 
     VersioningUtil.validateEntityExistence(imageEntity, new ImageEntity(vspId, version, componentId,
-            imageId), VspDetails.ENTITY_TYPE);
+        imageId), VspDetails.ENTITY_TYPE);
     return imageEntity;
   }
 
-
-  private boolean isImageNameDuplicate(Collection<ImageEntity> images, String fileName) {
-    for (ImageEntity image : images) {
-      if (image.getImageCompositionData().getFileName().equalsIgnoreCase(fileName)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   protected String getImageCompositionSchema(SchemaTemplateInput schemaInput) {
-    mdcDataDebugMessage.debugEntryMessage(null, null);
-    mdcDataDebugMessage.debugExitMessage(null, null);
+    mdcDataDebugMessage.debugEntryMessage(null);
+    mdcDataDebugMessage.debugExitMessage(null);
     return SchemaGenerator
-            .generate(SchemaTemplateContext.composition, CompositionEntityType.image,
-                    schemaInput);
+        .generate(SchemaTemplateContext.composition, CompositionEntityType.image,
+            schemaInput);
   }
 
   protected String getImageQuestionnaireSchema(SchemaTemplateInput schemaInput) {
-    mdcDataDebugMessage.debugEntryMessage(null, null);
+    mdcDataDebugMessage.debugEntryMessage(null);
 
-    mdcDataDebugMessage.debugExitMessage(null, null);
+    mdcDataDebugMessage.debugExitMessage(null);
     return SchemaGenerator
-            .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.image,
-                    schemaInput);
+        .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.image,
+            schemaInput);
   }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImpl.java
index 8bdc7fdfce..fdb9621bcb 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImpl.java
@@ -6,8 +6,6 @@ import org.openecomp.sdc.generator.core.services.ManualVspToscaGenerationService
 import org.openecomp.sdc.generator.datatypes.tosca.DeploymentFlavorModel;
 import org.openecomp.sdc.generator.datatypes.tosca.MultiFlavorVfcImage;
 import org.openecomp.sdc.generator.datatypes.tosca.VspModelInfo;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
 import org.openecomp.sdc.logging.types.LoggerConstants;
@@ -29,18 +27,15 @@ public class ManualVspToscaManagerImpl implements ManualVspToscaManager {
   private ManualVspDataCollectionService
       manualVspDataCollectionService = new ManualVspDataCollectionService();
 
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
-
   @Override
-  public VspModelInfo gatherVspInformation(String vspId, Version version, String user) {
+  public VspModelInfo gatherVspInformation(String vspId, Version version) {
     mdcDataDebugMessage.debugEntryMessage(null, null);
     VspModelInfo vspModelInfo = new VspModelInfo();
     //Get Release Vendor Name
     Optional<String> releaseVendor;
     try {
-      releaseVendor = manualVspDataCollectionService.getReleaseVendor(vspId, version, user);
+      releaseVendor = manualVspDataCollectionService.getReleaseVendor(vspId, version);
     } catch (Exception ex) {
-      log.debug("", ex);
       releaseVendor = Optional.empty();
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
           LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
@@ -52,9 +47,8 @@ public class ManualVspToscaManagerImpl implements ManualVspToscaManager {
     //Get Allowed Deployment flavors information
     Map<String, DeploymentFlavorModel> allowedFlavors;
     try {
-      allowedFlavors = manualVspDataCollectionService.getAllowedFlavors(vspId, version, user);
+      allowedFlavors = manualVspDataCollectionService.getAllowedFlavors(vspId, version);
     } catch (Exception ex) {
-      log.debug("", ex);
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
           LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to collect allowed flavors : "
@@ -69,9 +63,8 @@ public class ManualVspToscaManagerImpl implements ManualVspToscaManager {
     Map<String, List<MultiFlavorVfcImage>> vspComponentImages;
     try {
       vspComponentImages =
-          manualVspDataCollectionService.getVspComponentImages(vspId, version, user);
+          manualVspDataCollectionService.getVspComponentImages(vspId, version);
     } catch (Exception ex) {
-      log.debug("", ex);
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
           LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to collect vsp component images : "
@@ -85,9 +78,8 @@ public class ManualVspToscaManagerImpl implements ManualVspToscaManager {
     //Get VFC component information
     Map<String, String> vspComponents;
     try {
-      vspComponents = manualVspDataCollectionService.getVspComponents(vspId, version, user);
+      vspComponents = manualVspDataCollectionService.getVspComponents(vspId, version);
     } catch (Exception ex) {
-      log.debug("", ex);
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
           LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to collect vsp components : "
@@ -101,9 +93,8 @@ public class ManualVspToscaManagerImpl implements ManualVspToscaManager {
     //Get VSP component nic information
     Map<String, List<Nic>> vspComponentNics;
     try {
-      vspComponentNics = manualVspDataCollectionService.getVspComponentNics(vspId, version, user);
+      vspComponentNics = manualVspDataCollectionService.getVspComponentNics(vspId, version);
     } catch (Exception ex) {
-      log.debug("", ex);
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
           LoggerTragetServiceName.COLLECT_MANUAL_VSP_TOSCA_DATA, ErrorLevel.INFO.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Unable to collect vsp component nics : "
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerFactoryImpl.java
index 6569312f02..eed566de43 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerFactoryImpl.java
@@ -20,15 +20,13 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
-import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.MonitoringUploadsManager;
 import org.openecomp.sdc.vendorsoftwareproduct.MonitoringUploadsManagerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.MonitoringUploadDaoFactory;
 
 public class MonitoringUploadsManagerFactoryImpl extends MonitoringUploadsManagerFactory {
   private static final MonitoringUploadsManager INSTANCE =
-      new MonitoringUploadsManagerImpl(MonitoringUploadDaoFactory.getInstance().createInterface(),
-          ActivityLogManagerFactory.getInstance().createInterface());
+      new MonitoringUploadsManagerImpl(MonitoringUploadDaoFactory.getInstance().createInterface());
 
   @Override
   public MonitoringUploadsManager createInterface() {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImpl.java
index 0f4d73f8c5..bcfdefbd0c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImpl.java
@@ -26,8 +26,6 @@ import org.openecomp.core.utilities.CommonMethods;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.core.utilities.file.FileUtils;
 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
-import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.common.utils.CommonUtil;
@@ -45,7 +43,6 @@ import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
 import org.openecomp.sdc.vendorsoftwareproduct.MonitoringUploadsManager;
 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentArtifactDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentMonitoringUploadEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.MonitoringUploadErrorBuilder;
@@ -53,7 +50,6 @@ import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.MonitoringU
 import org.openecomp.sdc.vendorsoftwareproduct.utils.VendorSoftwareProductUtils;
 import org.openecomp.sdc.versioning.dao.types.Version;
 import org.openecomp.sdc.versioning.errors.VersionableSubEntityNotFoundErrorBuilder;
-import org.openecomp.sdcrests.activitylog.types.ActivityType;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -67,26 +63,20 @@ import java.util.Optional;
 
 public class MonitoringUploadsManagerImpl implements MonitoringUploadsManager {
   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
-  private ActivityLogManager activityLogManager;
   private ComponentArtifactDao componentArtifactDao;
-  private VendorSoftwareProductDao vendorSoftwareProductDao;
   private static final Logger logger =
       LoggerFactory.getLogger(VendorSoftwareProductManagerImpl.class);
 
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
-
-  MonitoringUploadsManagerImpl(ComponentArtifactDao componentArtifactDao,
-                               ActivityLogManager activityLogManager) {
+  MonitoringUploadsManagerImpl(ComponentArtifactDao componentArtifactDao) {
     this.componentArtifactDao = componentArtifactDao;
 
-    this.activityLogManager = activityLogManager;
     componentArtifactDao.registerVersioning(
         VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
   }
 
   @Override
   public void delete(String vspId, Version version, String componentId,
-                     MonitoringUploadType monitoringUploadType, String user) {
+                     MonitoringUploadType monitoringUploadType) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
     ComponentMonitoringUploadEntity componentMonitoringUploadEntity =
@@ -112,8 +102,7 @@ public class MonitoringUploadsManagerImpl implements MonitoringUploadsManager {
   @Override
   public void upload(InputStream object, String filename, String vspId,
                      Version version, String componentId,
-                     MonitoringUploadType type,
-                     String user) {
+                     MonitoringUploadType type) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
     if (object == null) {
@@ -130,7 +119,7 @@ public class MonitoringUploadsManagerImpl implements MonitoringUploadsManager {
         final FileContentHandler upload =
             validateZip(vspId, version, uploadedFileData, errors);
         if (type.equals(MonitoringUploadType.VES_EVENTS)) {
-          validateVesEventUpload(upload, errors, vspId, version);
+          validateVesEventUpload(upload, errors);
         }
         if (MapUtils.isNotEmpty(errors)) {
           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
@@ -147,27 +136,18 @@ public class MonitoringUploadsManagerImpl implements MonitoringUploadsManager {
             uploadedFileData);
 
       } catch (Exception exception) {
-        log.debug("", exception);
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
             LoggerTragetServiceName.UPLOAD_MONITORING_FILE, ErrorLevel.ERROR.name(),
             LoggerErrorCode.DATA_ERROR.getErrorCode(), "Invalid " + type.toString() + "zip file");
         throw new CoreException(new MonitoringUploadErrorBuilder(exception.getMessage()).build());
       }
     }
-
-    ActivityLogEntity activityLogEntity =
-        new ActivityLogEntity(vspId, String.valueOf(version.getMajor() + 1),
-            ActivityType.UPLOAD_MONITORING_FILE.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
     logger.audit("Uploaded Monitoring File for component id:" + componentId + " ,vspId:" + vspId);
-
-
     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
   }
 
   private void validateVesEventUpload(FileContentHandler upload,
-                                      Map<String, List<ErrorMessage>> errors, String vspId,
-                                      Version version) {
+                                      Map<String, List<ErrorMessage>> errors) {
     if (!CommonUtil.validateAllFilesYml(upload)) {
       ErrorMessage.ErrorMessageUtil.addMessage(SdcCommon.UPLOAD_FILE, errors)
           .add(new ErrorMessage(ErrorLevel.ERROR,
@@ -194,8 +174,7 @@ public class MonitoringUploadsManagerImpl implements MonitoringUploadsManager {
   }
 
   @Override
-  public MonitoringUploadStatus listFilenames(String vspId, Version version, String componentId,
-                                              String user) {
+  public MonitoringUploadStatus listFilenames(String vspId, Version version, String componentId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
     ComponentMonitoringUploadEntity current =
@@ -259,10 +238,10 @@ public class MonitoringUploadsManagerImpl implements MonitoringUploadsManager {
                                          Map<String, List<ErrorMessage>> errors) {
     FileContentHandler contentMap;
     try {
-      contentMap = CommonUtil.validateAndUploadFileContent(OnboardingTypesEnum.ZIP, uploadedFileData);
+      contentMap =
+          CommonUtil.validateAndUploadFileContent(OnboardingTypesEnum.ZIP, uploadedFileData);
       VendorSoftwareProductUtils.validateContentZipData(contentMap, errors);
     } catch (IOException exception) {
-      log.debug("", exception);
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.VALIDATE_MONITORING_FILE, ErrorLevel.ERROR.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Invalid Monitoring zip file");
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImpl.java
index 77b6b0039e..e6233bb79c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImpl.java
@@ -59,7 +59,7 @@ public class NetworkManagerImpl implements NetworkManager {
   }
 
   @Override
-  public Collection<NetworkEntity> listNetworks(String vspId, Version version, String user) {
+  public Collection<NetworkEntity> listNetworks(String vspId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
 
@@ -67,7 +67,7 @@ public class NetworkManagerImpl implements NetworkManager {
   }
 
   @Override
-  public NetworkEntity createNetwork(NetworkEntity network, String user) {
+  public NetworkEntity createNetwork(NetworkEntity network) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", network.getVspId());
 
     if (!isManual(network.getVspId(), network.getVersion())) {
@@ -87,16 +87,12 @@ public class NetworkManagerImpl implements NetworkManager {
     return null;
   }
 
-  private NetworkEntity createNetwork(NetworkEntity network) {
-    return compositionEntityDataManager.createNetwork(network);
-  }
-
   @Override
-  public CompositionEntityValidationData updateNetwork(NetworkEntity network, String user) {
+  public CompositionEntityValidationData updateNetwork(NetworkEntity network) {
     mdcDataDebugMessage
         .debugEntryMessage("VSP id, network id", network.getVspId(), network.getId());
 
-    NetworkEntity retrieved = getNetwork(network.getVspId(), network.getVersion(), network.getId());
+    NetworkEntity retrieved = getValidatedNetwork(network.getVspId(), network.getVersion(), network.getId());
 
     NetworkCompositionSchemaInput schemaInput = new NetworkCompositionSchemaInput();
     schemaInput.setManual(isManual(network.getVspId(), network.getVersion()));
@@ -119,10 +115,10 @@ public class NetworkManagerImpl implements NetworkManager {
 
   @Override
   public CompositionEntityResponse<Network> getNetwork(String vspId, Version version,
-                                                       String networkId, String user) {
+                                                       String networkId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, network id", vspId, networkId);
 
-    NetworkEntity networkEntity = getNetwork(vspId, version, networkId);
+    NetworkEntity networkEntity = getValidatedNetwork(vspId, version, networkId);
     Network network = networkEntity.getNetworkCompositionData();
 
     NetworkCompositionSchemaInput schemaInput = new NetworkCompositionSchemaInput();
@@ -140,7 +136,7 @@ public class NetworkManagerImpl implements NetworkManager {
   }
 
 
-  private NetworkEntity getNetwork(String vspId, Version version, String networkId) {
+  private NetworkEntity getValidatedNetwork(String vspId, Version version, String networkId) {
     NetworkEntity retrieved = networkDao.get(new NetworkEntity(vspId, version, networkId));
     VersioningUtil.validateEntityExistence(retrieved, new NetworkEntity(vspId, version, networkId),
         VspDetails.ENTITY_TYPE);
@@ -148,7 +144,7 @@ public class NetworkManagerImpl implements NetworkManager {
   }
 
   @Override
-  public void deleteNetwork(String vspId, Version version, String networkId, String user) {
+  public void deleteNetwork(String vspId, Version version, String networkId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, network id", vspId, networkId);
 
     if (!isManual(vspId, version)) {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImpl.java
index 0304353113..f2bb0baf95 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImpl.java
@@ -37,7 +37,12 @@ import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
-import org.openecomp.sdc.vendorsoftwareproduct.errors.*;
+import org.openecomp.sdc.vendorsoftwareproduct.errors.DeleteNicErrorBuilder;
+import org.openecomp.sdc.vendorsoftwareproduct.errors.DuplicateNicInComponentErrorBuilder;
+import org.openecomp.sdc.vendorsoftwareproduct.errors.NicErrorBuilder;
+import org.openecomp.sdc.vendorsoftwareproduct.errors.NicInternalNetworkErrorBuilder;
+import org.openecomp.sdc.vendorsoftwareproduct.errors.NicNetworkIdNotAllowedExternalNetworkErrorBuilder;
+import org.openecomp.sdc.vendorsoftwareproduct.errors.NotSupportedHeatOnboardMethodErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
 import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
@@ -63,7 +68,7 @@ public class NicManagerImpl implements NicManager {
   private NicDao nicDao;
   private CompositionEntityDataManager compositionEntityDataManager;
   private NetworkManager networkManager;
-  private  VendorSoftwareProductInfoDao vspInfoDao;
+  private VendorSoftwareProductInfoDao vspInfoDao;
 
   public NicManagerImpl(NicDao nicDao,
                         CompositionEntityDataManager compositionEntityDataManager,
@@ -76,14 +81,13 @@ public class NicManagerImpl implements NicManager {
   }
 
   @Override
-  public Collection<NicEntity> listNics(String vspId, Version version, String componentId,
-                                        String user) {
+  public Collection<NicEntity> listNics(String vspId, Version version, String componentId) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
     Collection<NicEntity> nics = nicDao.list(new NicEntity(vspId, version, componentId, null));
 
     if (!nics.isEmpty()) {
-      Map<String, String> networksNameById = listNetworksNameById(vspId, version, user);
+      Map<String, String> networksNameById = listNetworksNameById(vspId, version);
       nics.forEach(nicEntity -> {
         Nic nic = nicEntity.getNicCompositionData();
         nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
@@ -96,18 +100,18 @@ public class NicManagerImpl implements NicManager {
     return nics;
   }
 
-  private Map<String, String> listNetworksNameById(String vspId, Version version, String user) {
-    Collection<NetworkEntity> networks = networkManager.listNetworks(vspId, version, user);
+  private Map<String, String> listNetworksNameById(String vspId, Version version) {
+    Collection<NetworkEntity> networks = networkManager.listNetworks(vspId, version);
     return networks.stream().collect(Collectors.toMap(NetworkEntity::getId,
         networkEntity -> networkEntity.getNetworkCompositionData().getName()));
   }
 
   @Override
-  public NicEntity createNic(NicEntity nic, String user) {
-    NicEntity createdNic = null;
+  public NicEntity createNic(NicEntity nic) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", nic.getVspId(),
         nic.getComponentId());
 
+    NicEntity createdNic;
     if (!vspInfoDao.isManual(nic.getVspId(), nic.getVersion())) {
       ErrorCode onboardingMethodUpdateErrorCode = NotSupportedHeatOnboardMethodErrorBuilder
           .getAddNicNotSupportedHeatOnboardMethodErrorBuilder();
@@ -117,25 +121,20 @@ public class NicManagerImpl implements NicManager {
           onboardingMethodUpdateErrorCode.message());
       throw new CoreException(onboardingMethodUpdateErrorCode);
     } else {
-      validateNic(nic, user);
-      createdNic = createNic(nic);
+      validateNic(nic);
+      createdNic = compositionEntityDataManager.createNic(nic);
     }
 
-    //nicDao.updateVspLatestModificationTime(nic.getVspId(), nic.getVersion());
-
     mdcDataDebugMessage
         .debugExitMessage("VSP id, component id", nic.getVspId(), nic.getComponentId());
 
     return createdNic;
   }
 
-  private NicEntity createNic(NicEntity nic) {
-    return compositionEntityDataManager.createNic(nic);
-  }
 
-  private void validateNic(NicEntity nic, String user) {
+  private void validateNic(NicEntity nic) {
     Collection<NicEntity> listNics = listNics(nic.getVspId(), nic.getVersion(), nic
-        .getComponentId(), user);
+        .getComponentId());
     String networkId = nic.getNicCompositionData().getNetworkId();
     NetworkType networkType = nic.getNicCompositionData().getNetworkType();
     String networkDescription = nic.getNicCompositionData().getNetworkDescription();
@@ -171,14 +170,12 @@ public class NicManagerImpl implements NicManager {
       if (!(networkId == null || networkId.equals(""))) {
         //NetworkEntity ne = getNetwork(nic.getVspId(), activeVersion, networkId);
         final CompositionEntityResponse<Network> network =
-            networkManager.getNetwork(nic.getVspId(), nic.getVersion(), networkId,
-                user);
+            networkManager.getNetwork(nic.getVspId(), nic.getVersion(), networkId);
       }
 
       if (!(networkDescription == null || networkDescription.equals(""))) {
         final ErrorCode nicNetworkDescriptionErrorBuilder =
-            new NicInternalNetworkErrorBuilder()
-                .getNetworkDescriptionInternalNetworkErrorBuilder();
+            NicInternalNetworkErrorBuilder.getNetworkDescriptionInternalNetworkErrorBuilder();
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
             LoggerTragetServiceName.CREATE_NIC, ErrorLevel.ERROR.name(),
             LoggerErrorCode.DATA_ERROR.getErrorCode(), nicNetworkDescriptionErrorBuilder.message());
@@ -200,17 +197,17 @@ public class NicManagerImpl implements NicManager {
 
   @Override
   public CompositionEntityResponse<Nic> getNic(String vspId, Version version, String componentId,
-                                               String nicId, String user) {
+                                               String nicId) {
     mdcDataDebugMessage
         .debugEntryMessage("VSP id, component id, nic id", vspId, componentId, nicId);
 
-    NicEntity nicEntity = getNic(vspId, version, componentId, nicId);
+    NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
     Nic nic = nicEntity.getNicCompositionData();
 
     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
     schemaInput.setManual(vspInfoDao.isManual(vspId, version));
     schemaInput.setNic(nic);
-    Map<String, String> networksNameById = listNetworksNameById(vspId, version, user);
+    Map<String, String> networksNameById = listNetworksNameById(vspId, version);
     nic.setNetworkName(networksNameById.get(nic.getNetworkId()));
     schemaInput.setNetworkIds(networksNameById.keySet());
 
@@ -226,7 +223,8 @@ public class NicManagerImpl implements NicManager {
   }
 
 
-  private NicEntity getNic(String vspId, Version version, String componentId, String nicId) {
+  private NicEntity getValidatedNic(String vspId, Version version, String componentId,
+                                    String nicId) {
     NicEntity retrieved = nicDao.get(new NicEntity(vspId, version, componentId, nicId));
     VersioningUtil
         .validateEntityExistence(retrieved, new NicEntity(vspId, version, componentId, nicId),
@@ -235,14 +233,13 @@ public class NicManagerImpl implements NicManager {
   }
 
   @Override
-  public void deleteNic(String vspId, Version version, String componentId, String nicId,
-                        String user) {
+  public void deleteNic(String vspId, Version version, String componentId, String nicId) {
     mdcDataDebugMessage
         .debugEntryMessage("VSP id, component id", vspId, componentId, nicId);
 
     if (!vspInfoDao.isManual(vspId, version)) {
       final ErrorCode deleteNicErrorBuilder =
-          new DeleteNicErrorBuilder().getDeleteNicForHeatOnboardedVspErrorBuilder();
+          DeleteNicErrorBuilder.getDeleteNicForHeatOnboardedVspErrorBuilder();
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.DELETE_NIC, ErrorLevel.ERROR.name(),
           LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
@@ -250,23 +247,21 @@ public class NicManagerImpl implements NicManager {
       throw new CoreException(deleteNicErrorBuilder);
     }
 
-    NicEntity nicEntity = getNic(vspId, version, componentId, nicId);
-    if (nicEntity != null) {
-      nicDao.delete(nicEntity);
-    }
+    NicEntity nicEntity = getValidatedNic(vspId, version, componentId, nicId);
+    nicDao.delete(nicEntity);
 
     mdcDataDebugMessage
         .debugExitMessage("VSP id, component id", vspId, componentId, nicId);
   }
 
   @Override
-  public CompositionEntityValidationData updateNic(NicEntity nic, String user) {
+  public CompositionEntityValidationData updateNic(NicEntity nic) {
     mdcDataDebugMessage
         .debugEntryMessage("VSP id, component id", nic.getVspId(), nic.getComponentId(),
             nic.getId());
 
     NicEntity retrieved =
-        getNic(nic.getVspId(), nic.getVersion(), nic.getComponentId(), nic.getId());
+        getValidatedNic(nic.getVspId(), nic.getVersion(), nic.getComponentId(), nic.getId());
 
     NicCompositionSchemaInput schemaInput = new NicCompositionSchemaInput();
     schemaInput.setManual(vspInfoDao.isManual(nic.getVspId(), nic.getVersion()));
@@ -289,9 +284,6 @@ public class NicManagerImpl implements NicManager {
     if (CollectionUtils.isEmpty(validationData.getErrors())) {
       nicDao.update(nic);
     }
-
-    //nicDao.updateVspLatestModificationTime(nic.getVspId(), nic.getVersion());
-
     mdcDataDebugMessage
         .debugExitMessage("VSP id, component id", nic.getVspId(), nic.getComponentId(),
             nic.getId());
@@ -301,7 +293,7 @@ public class NicManagerImpl implements NicManager {
 
   @Override
   public QuestionnaireResponse getNicQuestionnaire(String vspId, Version version,
-                                                   String componentId, String nicId, String user) {
+                                                   String componentId, String nicId) {
     mdcDataDebugMessage
         .debugEntryMessage("VSP id, component id", vspId, componentId, nicId);
 
@@ -321,15 +313,13 @@ public class NicManagerImpl implements NicManager {
 
   @Override
   public void updateNicQuestionnaire(String vspId, Version version, String componentId,
-                                     String nicId, String questionnaireData, String user) {
+                                     String nicId, String questionnaireData) {
     mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId, nicId);
 
     getNic(vspId, version, componentId, nicId);
 
     nicDao.updateQuestionnaireData(vspId, version, componentId, nicId, questionnaireData);
 
-    //nicDao.updateVspLatestModificationTime(vspId, version);
-
     mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId, nicId);
   }
 
@@ -342,9 +332,4 @@ public class NicManagerImpl implements NicManager {
     return SchemaGenerator
         .generate(SchemaTemplateContext.composition, CompositionEntityType.nic, schemaInput);
   }
-  // todo *************************** move to reusable place! *************************
-
-  /*private boolean isManual(String vspId, Version version) {
-    return false;
-  }*/
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerFactoryImpl.java
index b5464e5708..b8fddcd075 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerFactoryImpl.java
@@ -20,40 +20,21 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
-import org.openecomp.core.model.dao.ServiceModelDaoFactory;
-import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
 import org.openecomp.sdc.healing.factory.HealingManagerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManager;
 import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManagerFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.MonitoringUploadDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.factory.CandidateServiceFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.factory.CompositionDataExtractorFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.factory.CompositionEntityDataManagerFactory;
 
 public class OrchestrationTemplateCandidateManagerFactoryImpl extends
     OrchestrationTemplateCandidateManagerFactory {
+
   private static final OrchestrationTemplateCandidateManager INSTANCE =
       new OrchestrationTemplateCandidateManagerImpl(
-          VendorSoftwareProductDaoFactory.getInstance().createInterface(),
           VendorSoftwareProductInfoDaoFactory.getInstance().createInterface(),
-          OrchestrationTemplateDaoFactory.getInstance().createInterface(),
           CandidateServiceFactory.getInstance().createInterface(),
-          HealingManagerFactory.getInstance().createInterface(),
-          CompositionDataExtractorFactory.getInstance().createInterface(),
-          ServiceModelDaoFactory.getInstance().createInterface(),
-          CompositionEntityDataManagerFactory.getInstance().createInterface(),
-          NicDaoFactory.getInstance().createInterface(),
-          ComponentDaoFactory.getInstance().createInterface(),
-          MonitoringUploadDaoFactory.getInstance().createInterface(),
-          ProcessDaoFactory.getInstance().createInterface(),
-          ActivityLogManagerFactory.getInstance().createInterface());
-
+          HealingManagerFactory.getInstance().createInterface()
+      );
 
   @Override
   public OrchestrationTemplateCandidateManager createInterface() {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImpl.java
index 07a3fa7f2c..f613dbb54f 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImpl.java
@@ -23,11 +23,8 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
-import org.openecomp.core.model.dao.ServiceModelDao;
-import org.openecomp.core.model.types.ServiceElement;
 import org.openecomp.core.utilities.json.JsonUtil;
 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.common.utils.CommonUtil;
@@ -35,7 +32,6 @@ import org.openecomp.sdc.common.utils.SdcCommon;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
 import org.openecomp.sdc.datatypes.error.ErrorMessage;
 import org.openecomp.sdc.healing.api.HealingManager;
-import org.openecomp.sdc.healing.types.HealCode;
 import org.openecomp.sdc.logging.api.Logger;
 import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.logging.api.annotations.Metrics;
@@ -43,14 +39,7 @@ import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.logging.messages.AuditMessages;
 import org.openecomp.sdc.logging.types.LoggerServiceName;
 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
-import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
 import org.openecomp.sdc.vendorsoftwareproduct.OrchestrationTemplateCandidateManager;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentArtifactDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateCandidateData;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
@@ -58,9 +47,6 @@ import org.openecomp.sdc.vendorsoftwareproduct.errors.OrchestrationTemplateNotFo
 import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.OrchestrationTemplateFileHandler;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.OrchestrationUploadFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.process.OrchestrationProcessFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.process.OrchestrationTemplateProcessHandler;
-import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionDataExtractor;
-import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
 import org.openecomp.sdc.vendorsoftwareproduct.types.OrchestrationTemplateActionResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
@@ -80,114 +66,52 @@ public class OrchestrationTemplateCandidateManagerImpl
   private static final Logger logger =
       LoggerFactory.getLogger(OrchestrationTemplateCandidateManagerImpl.class);
   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
-  private VendorSoftwareProductDao vendorSoftwareProductDao;
+
   private VendorSoftwareProductInfoDao vspInfoDao;
-  private OrchestrationTemplateDao orchestrationTemplateDataDao;
   private CandidateService candidateService;
   private HealingManager healingManager;
-  private CompositionDataExtractor compositionDataExtractor;
-  private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
-  private CompositionEntityDataManager compositionEntityDataManager;
-  private NicDao nicDao;
-  private ComponentDao componentDao;
-  private ComponentArtifactDao componentArtifactDao;
-  private ActivityLogManager activityLogManager;
-  private ProcessDao processDao;
-
-  /**
-   * Instantiates a new Orchestration template candidate manager.
-   *
-   * @param vendorSoftwareProductDao     the vendor software product dao
-   * @param vspInfoDao                   the vsp info dao
-   * @param orchestrationTemplateDataDao the orchestration template data dao
-   * @param candidateService             the candidate service
-   * @param healingManager               the healing manager
-   * @param compositionDataExtractor     the composition data extractor
-   * @param serviceModelDao              the service model dao
-   * @param compositionEntityDataManager the composition entity data manager
-   * @param nicDao                       the nic dao
-   * @param componentDao                 the component dao
-   * @param componentArtifactDao                       the mib dao
-   * @param processDao                   the process dao
-   * @param activityLogManager           the activity log manager
-   */
-  public OrchestrationTemplateCandidateManagerImpl(
-      VendorSoftwareProductDao vendorSoftwareProductDao, VendorSoftwareProductInfoDao
-      vspInfoDao,
-      OrchestrationTemplateDao orchestrationTemplateDataDao,
-      CandidateService candidateService, HealingManager healingManager,
-      CompositionDataExtractor compositionDataExtractor,
-      ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao,
-      CompositionEntityDataManager compositionEntityDataManager,
-      NicDao nicDao,
-      ComponentDao componentDao,
-      ComponentArtifactDao componentArtifactDao,
-      ProcessDao processDao,
-      ActivityLogManager activityLogManager) {
-    this.vendorSoftwareProductDao = vendorSoftwareProductDao;
+
+  public OrchestrationTemplateCandidateManagerImpl(VendorSoftwareProductInfoDao vspInfoDao,
+                                                   CandidateService candidateService,
+                                                   HealingManager healingManager) {
     this.vspInfoDao = vspInfoDao;
-    this.orchestrationTemplateDataDao = orchestrationTemplateDataDao;
     this.candidateService = candidateService;
     this.healingManager = healingManager;
-    this.compositionDataExtractor = compositionDataExtractor;
-    this.serviceModelDao = serviceModelDao;
-    this.compositionEntityDataManager = compositionEntityDataManager;
-    this.nicDao = nicDao;
-    this.componentDao = componentDao;
-    this.componentArtifactDao = componentArtifactDao;
-    this.processDao = processDao;
-    this.activityLogManager = activityLogManager;
   }
 
   @Override
   @Metrics
   public UploadFileResponse upload(String vspId, Version version, InputStream fileToUpload,
-                                   String user, String filePrefix,
-                                   String networkPackageName) {
+                                   String fileSuffix, String networkPackageName) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
+
     OrchestrationTemplateFileHandler orchestrationTemplateFileHandler =
-            OrchestrationUploadFactory.createOrchestrationTemplateFileHandler(filePrefix);
+        OrchestrationUploadFactory.createOrchestrationTemplateFileHandler(fileSuffix);
+
     VspDetails vspDetails = getVspDetails(vspId, version);
+
     UploadFileResponse uploadResponse = orchestrationTemplateFileHandler
-        .upload(vspId, version, fileToUpload, user, candidateService,
-            vspDetails);
-    vspDetails.setOnboardingOrigin(filePrefix);
-    vspDetails.setNetworkPackageName(networkPackageName);
-    vspInfoDao.update(vspDetails);
+        .upload(vspDetails, fileToUpload, fileSuffix, networkPackageName, candidateService);
 
     uploadResponse.setNetworkPackageName(networkPackageName);
     return uploadResponse;
   }
 
-
-
   @Override
-  public OrchestrationTemplateActionResponse process(String vspId,
-                                                     Version version, String user) {
+  public OrchestrationTemplateActionResponse process(String vspId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
-    OrchestrationTemplateActionResponse response = new OrchestrationTemplateActionResponse();
-
-    Optional<OrchestrationTemplateCandidateData> candidate =
-        fetchCandidateDataEntity(vspId, version);
-    if (!candidate.isPresent()) {
-      throw new CoreException(new OrchestrationTemplateNotFoundErrorBuilder(vspId).build());
-    }
 
-    VspDetails vspDetails =
-        getVspDetails(vspId, version);
-    Optional<OrchestrationTemplateProcessHandler> processInstance =
-        OrchestrationProcessFactory.getInstance(vspDetails.getOnboardingOrigin());
+    OrchestrationTemplateCandidateData candidate = fetchCandidateDataEntity(vspId, version)
+        .orElseThrow(
+            () -> new CoreException(new OrchestrationTemplateNotFoundErrorBuilder(vspId).build()));
 
-    if(processInstance.isPresent()){
-      response = processInstance.get().process(vspDetails, candidate.get(), user);
-    }
-
-    return response;
+    return OrchestrationProcessFactory.getInstance(candidate.getFileSuffix())
+        .map(processor -> processor.process(getVspDetails(vspId, version), candidate))
+        .orElse(new OrchestrationTemplateActionResponse());
   }
 
   @Override
-  public Optional<FilesDataStructure> getFilesDataStructure(
-      String vspId, Version version, String user) {
+  public Optional<FilesDataStructure> getFilesDataStructure(String vspId, Version version) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
 
     Optional<FilesDataStructure> candidateFileDataStructure =
@@ -195,19 +119,13 @@ public class OrchestrationTemplateCandidateManagerImpl
     if (candidateFileDataStructure.isPresent()) {
       return candidateFileDataStructure;
     } else {
-      Map<String, Object> healingParams = getHealingParamsAsMap(vspId, version, user);
-
-      mdcDataDebugMessage
-          .debugExitMessage("VSP id", vspId);
-      return (Optional<FilesDataStructure>) healingManager
-          .heal(HealCode.FILE_DATA_STRUCTURE_HEALER, healingParams);
+      mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
+      return Optional.empty();
     }
   }
 
   @Override
-
-  public ValidationResponse updateFilesDataStructure(String vspId,
-                                                     Version version, String user,
+  public ValidationResponse updateFilesDataStructure(String vspId, Version version,
                                                      FilesDataStructure fileDataStructure) {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
 
@@ -222,27 +140,23 @@ public class OrchestrationTemplateCandidateManagerImpl
         response.setUploadDataErrors(errorsMap, LoggerServiceName.Update_Manifest,
             LoggerTragetServiceName.VALIDATE_FILE_DATA_STRUCTURE);
 
-        mdcDataDebugMessage
-            .debugExitMessage("VSP id", vspId);
+        mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
         return response;
       }
     }
-    candidateService.updateOrchestrationTemplateCandidateFileDataStructure(vspId, version,
-        fileDataStructure);
+    candidateService
+        .updateOrchestrationTemplateCandidateFileDataStructure(vspId, version, fileDataStructure);
 
-    mdcDataDebugMessage
-        .debugExitMessage("VSP id", vspId);
+    mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
     return response;
   }
 
   @Override
 
-  public Optional<Pair<String, byte[]>> get(String vspId, Version version, String user)
-      throws IOException {
+  public Optional<Pair<String, byte[]>> get(String vspId, Version version) throws IOException {
     mdcDataDebugMessage.debugEntryMessage("VSP id", vspId);
 
-    VspDetails vspDetails =
-        getVspDetails(vspId, version);
+    VspDetails vspDetails = getVspDetails(vspId, version);
 
     Optional<OrchestrationTemplateCandidateData> candidateDataEntity =
         fetchCandidateDataEntity(vspId, version);
@@ -252,31 +166,34 @@ public class OrchestrationTemplateCandidateManagerImpl
           Messages.NO_ZIP_FILE_WAS_UPLOADED_OR_ZIP_NOT_EXIST.getErrorMessage());
       logger.error(errorMessage.getMessage());
 
-      mdcDataDebugMessage
-          .debugExitMessage("VSP id", vspId);
+      mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
       return Optional.empty();
     }
     OnboardingTypesEnum type =
-        OnboardingTypesEnum.getOnboardingTypesEnum(vspDetails.getOnboardingOrigin());
+        OnboardingTypesEnum.getOnboardingTypesEnum(candidateDataEntity.get().getFileSuffix());
 
-    if(CommonUtil.isFileOriginFromZip(vspDetails.getOnboardingOrigin())) {
+    if (CommonUtil.isFileOriginFromZip(candidateDataEntity.get().getFileSuffix())) {
       FilesDataStructure structure = JsonUtil
           .json2Object(candidateDataEntity.get().getFilesDataStructure(), FilesDataStructure.class);
       String manifest = candidateService.createManifest(vspDetails, structure);
 
-      mdcDataDebugMessage
-          .debugExitMessage("VSP id", vspId);
+      mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
       return Optional.of(
-          new ImmutablePair<>(OnboardingTypesEnum.ZIP.toString(),candidateService
+          new ImmutablePair<>(OnboardingTypesEnum.ZIP.toString(), candidateService
               .replaceManifestInZip(candidateDataEntity.get().getContentData(),
-              manifest, vspId, type)));
+                  manifest, vspId, type)));
     }
 
     return Optional.of(
-        new ImmutablePair<>(vspDetails.getOnboardingOrigin(),candidateDataEntity.get()
+        new ImmutablePair<>(candidateDataEntity.get().getFileSuffix(), candidateDataEntity.get()
             .getContentData().array()));
   }
 
+  @Override
+  public OrchestrationTemplateCandidateData getInfo(String vspId, Version version) {
+    return candidateService.getOrchestrationTemplateCandidateInfo(vspId, version);
+  }
+
   private Optional<OrchestrationTemplateCandidateData> fetchCandidateDataEntity(
       String vspId, Version version) {
     return Optional
@@ -286,19 +203,22 @@ public class OrchestrationTemplateCandidateManagerImpl
 
   // todo *************************** move to reusable place! *************************
 
-  private Map<String, Object> getHealingParamsAsMap(String vspId, Version version, String user) {
+  private Map<String, Object> getHealingParamsAsMap(String vspId, Version version) {
     Map<String, Object> healingParams = new HashMap<>();
 
     healingParams.put(SdcCommon.VSP_ID, vspId);
     healingParams.put(SdcCommon.VERSION, version);
-    healingParams.put(SdcCommon.USER, user);
 
     return healingParams;
   }
 
   private VspDetails getVspDetails(String vspId, Version version) {
     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
-    vspDetails.setValidationData(orchestrationTemplateDataDao.getValidationData(vspId, version));
+/*    OrchestrationTemplateEntity orchestrationTemplateInfo =
+        orchestrationTemplateDao.getInfo(vspId, version);
+    vspDetails.setValidationData(orchestrationTemplateInfo.getValidationData());
+    vspDetails.setNetworkPackageName(orchestrationTemplateInfo.getFileName());
+    vspDetails.setOnboardingOrigin(orchestrationTemplateInfo.getFileSuffix());*/
     return vspDetails;
   }
 
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerFactoryImpl.java
index d870454de7..7a4e4876d2 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerFactoryImpl.java
@@ -20,16 +20,13 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
-import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.ProcessManager;
 import org.openecomp.sdc.vendorsoftwareproduct.ProcessManagerFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDaoFactory;
 
 public class ProcessManagerFactoryImpl extends ProcessManagerFactory {
   private static final ProcessManager INSTANCE =
-      new ProcessManagerImpl(
-              VendorSoftwareProductDaoFactory.getInstance().createInterface(),
-              ActivityLogManagerFactory.getInstance().createInterface());
+      new ProcessManagerImpl(ProcessDaoFactory.getInstance().createInterface());
 
   @Override
   public ProcessManager createInterface() {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImpl.java
index a3d0286019..121abda1ee 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImpl.java
@@ -22,12 +22,10 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 import org.openecomp.core.util.UniqueValueUtil;
 import org.openecomp.core.utilities.file.FileUtils;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
-import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
 import org.openecomp.sdc.logging.types.LoggerConstants;
@@ -35,138 +33,133 @@ import org.openecomp.sdc.logging.types.LoggerErrorCode;
 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
 import org.openecomp.sdc.vendorsoftwareproduct.ProcessManager;
 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.UploadInvalidErrorBuilder;
 import org.openecomp.sdc.versioning.VersioningUtil;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdcrests.activitylog.types.ActivityType;
+import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.ByteBuffer;
 import java.util.Collection;
 
 public class ProcessManagerImpl implements ProcessManager {
-  private static final MdcDataDebugMessage MDC_DATA_DEBUG_MESSAGE = new MdcDataDebugMessage();
-  private final ActivityLogManager activityLogManager;
+  private static final String PROCESS_ARTIFACT_NOT_EXIST_MSG =
+      "Process artifact for process with Id %s does not exist for %s with Id %s and version %s";
 
-  private final VendorSoftwareProductDao vendorSoftwareProductDao;
+  private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
 
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+  private ProcessDao processDao;
 
-  public ProcessManagerImpl(VendorSoftwareProductDao vendorSoftwareProductDao, ActivityLogManager activityLogManager) {
-    this.vendorSoftwareProductDao = vendorSoftwareProductDao;
-    this.activityLogManager = activityLogManager;
+  public ProcessManagerImpl(ProcessDao processDao) {
+    this.processDao = processDao;
   }
 
   @Override
   public Collection<ProcessEntity> listProcesses(String vspId, Version version,
-                                                 String componentId,
-                                                 String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", vspId, componentId);
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", vspId, componentId);
+                                                 String componentId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 
-    return vendorSoftwareProductDao.listProcesses(vspId, version, componentId);
+    return processDao.list(new ProcessEntity(vspId, version, componentId, null));
   }
 
   @Override
-  public void deleteProcesses(String vspId, Version version, String componentId, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", vspId, componentId);
+  public void deleteProcesses(String vspId, Version version, String componentId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
-    Collection<ProcessEntity> processes =
-        vendorSoftwareProductDao.listProcesses(vspId, version, componentId);
+    ProcessEntity allProcesses = new ProcessEntity(vspId, version, componentId, null);
+    Collection<ProcessEntity> processes = processDao.list(allProcesses);
 
     if (!processes.isEmpty()) {
       for (ProcessEntity process : processes) {
         deleteUniqueValue(process.getVspId(), process.getVersion(), process.getComponentId(),
             process.getName());
       }
+    }
 
-      vendorSoftwareProductDao.deleteProcesses(vspId, version, componentId);
+    if (componentId == null) {
+      processDao.deleteVspAll(vspId,version);
+    } else {
+      processDao.deleteAll(allProcesses);
     }
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", vspId, componentId);
+
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
   }
 
   @Override
-  public ProcessEntity createProcess(ProcessEntity process, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", process.getId(),
+  public ProcessEntity createProcess(ProcessEntity process) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", process.getId(),
         process.getComponentId());
     validateUniqueName(process.getVspId(), process.getVersion(), process.getComponentId(),
         process.getName());
-    //process.setId(CommonMethods.nextUuId());
 
-    vendorSoftwareProductDao.createProcess(process);
+    processDao.create(process);
     createUniqueName(process.getVspId(), process.getVersion(), process.getComponentId(),
         process.getName());
 
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", process.getId(),
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", process.getId(),
         process.getComponentId());
 
     return process;
   }
 
-
   @Override
   public ProcessEntity getProcess(String vspId, Version version, String componentId,
-                                  String processId, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", vspId, componentId);
+                                  String processId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
     ProcessEntity retrieved =
-        vendorSoftwareProductDao.getProcess(vspId, version, componentId, processId);
+        processDao.get(new ProcessEntity(vspId, version, componentId, processId));
     validateProcessExistence(vspId, version, componentId, processId, retrieved);
 
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", vspId, componentId);
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 
     return retrieved;
   }
 
   @Override
-  public void updateProcess(ProcessEntity process, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", process.getId(),
+  public void updateProcess(ProcessEntity process) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", process.getId(),
         process.getComponentId());
 
-    ProcessEntity retrieved = vendorSoftwareProductDao
-        .getProcess(process.getVspId(), process.getVersion(), process.getComponentId(),
-            process.getId());
+    ProcessEntity retrieved = processDao.get(process);
     validateProcessExistence(process.getVspId(), process.getVersion(), process.getComponentId(),
         process.getId(), retrieved);
 
     updateUniqueName(process.getVspId(), process.getVersion(), process.getComponentId(),
         retrieved.getName(), process.getName());
-    vendorSoftwareProductDao.updateProcess(process);
+    processDao.update(process);
 
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", process.getId(),
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", process.getId(),
         process.getComponentId());
   }
 
   @Override
-  public void deleteProcess(String vspId, Version version, String componentId, String processId,
-                            String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", vspId, componentId);
+  public void deleteProcess(String vspId, Version version, String componentId, String processId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
-    ProcessEntity retrieved =
-        vendorSoftwareProductDao.getProcess(vspId, version, componentId, processId);
-    validateProcessExistence(vspId, version, componentId, processId, retrieved);
+    ProcessEntity retrieved = getProcess(vspId, version, componentId, processId);
 
-    vendorSoftwareProductDao.deleteProcess(vspId, version, componentId, processId);
+    processDao.delete(retrieved);
     deleteUniqueValue(retrieved.getVspId(), retrieved.getVersion(), retrieved.getComponentId(),
         retrieved.getName());
 
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", vspId, componentId);
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
   }
 
 
   @Override
   public File getProcessArtifact(String vspId, Version version, String componentId,
-                                 String processId, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", vspId, componentId);
+                                 String processId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
-    ProcessEntity retrieved =
-        vendorSoftwareProductDao.getProcessArtifact(vspId, version, componentId, processId);
-    validateProcessArtifactExistence(vspId, version, componentId, processId, retrieved);
+    ProcessEntity retrieved = getValidatedProcessArtifact(vspId, version, componentId, processId);
 
     File file = new File(String.format("%s_%s_%s", vspId, componentId, processId));
     try (FileOutputStream fos = new FileOutputStream(file)) {
@@ -175,125 +168,115 @@ public class ProcessManagerImpl implements ProcessManager {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.GET_PROCESS_ARTIFACT, ErrorLevel.ERROR.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't get process artifact");
-      throw new CoreException(new UploadInvalidErrorBuilder().build(), exception);
+      throw new CoreException(new UploadInvalidErrorBuilder().build());
     }
 
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", vspId, componentId);
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
 
     return file;
   }
 
   @Override
   public void deleteProcessArtifact(String vspId, Version version, String componentId,
-                                    String processId, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", vspId, componentId);
+                                    String processId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
 
-    ProcessEntity retrieved =
-        vendorSoftwareProductDao.getProcessArtifact(vspId, version, componentId, processId);
-    validateProcessArtifactExistence(vspId, version, componentId, processId, retrieved);
+    ProcessEntity retrieved = getValidatedProcessArtifact(vspId, version, componentId, processId);
 
-    vendorSoftwareProductDao.deleteProcessArtifact(vspId, version, componentId, processId);
+    processDao.deleteArtifact(retrieved);
 
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", vspId, componentId);
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
   }
 
   @Override
   public void uploadProcessArtifact(InputStream artifactFile, String artifactFileName, String vspId,
-                                    Version version, String componentId, String processId,
-                                    String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id", vspId, componentId);
+                                    Version version, String componentId, String processId) {
+    mdcDataDebugMessage.debugEntryMessage("VSP id, component id", vspId, componentId);
+
+    ProcessEntity process = getProcess(vspId, version, componentId, processId);
+    process.setArtifactName(artifactFileName);
+    process.setArtifact(readArtifact(artifactFile));
+    processDao.uploadArtifact(process);
 
+    mdcDataDebugMessage.debugExitMessage("VSP id, component id", vspId, componentId);
+  }
+
+  private ProcessEntity getValidatedProcessArtifact(String vspId, Version version,
+                                                    String componentId, String processId) {
     ProcessEntity retrieved =
-        vendorSoftwareProductDao.getProcess(vspId, version, componentId, processId);
-    validateProcessExistence(vspId, version, componentId, processId, retrieved);
+        processDao.getArtifact(new ProcessEntity(vspId, version, componentId, processId));
+    validateProcessArtifactExistence(vspId, version, componentId, processId, retrieved);
+    return retrieved;
+  }
 
-    if (artifactFile == null) {
+  private ByteBuffer readArtifact(InputStream artifactInputStream) {
+    if (artifactInputStream == null) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.UPLOAD_PROCESS_ARTIFACT, ErrorLevel.ERROR.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't upload process artifact");
       throw new CoreException(new UploadInvalidErrorBuilder().build());
     }
-
-    byte[] artifact;
     try {
-      artifact = FileUtils.toByteArray(artifactFile);
+      return ByteBuffer.wrap(FileUtils.toByteArray(artifactInputStream));
     } catch (RuntimeException exception) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
           LoggerTragetServiceName.UPLOAD_PROCESS_ARTIFACT, ErrorLevel.ERROR.name(),
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't upload process artifact");
-      throw new CoreException(new UploadInvalidErrorBuilder().build(), exception);
+      throw new CoreException(new UploadInvalidErrorBuilder().build());
     }
-
-    vendorSoftwareProductDao.uploadProcessArtifact(vspId, version, componentId, processId, artifact,
-            artifactFileName);
-    ActivityLogEntity activityLogEntity = new ActivityLogEntity(vspId, String.valueOf(version.getMajor()+1),
-        ActivityType.UPLOAD_MONITORING_FILE.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id", vspId, componentId);
   }
 
 
   private void validateProcessExistence(String vspId, Version version, String componentId,
                                         String processId, ProcessEntity retrieved) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id, process id", vspId, componentId,
-        processId);
-
-    if (retrieved != null) {
-      return;
-    }
     VersioningUtil.validateEntityExistence(retrieved,
         new ProcessEntity(vspId, version, componentId, processId),
-        VspDetails.ENTITY_TYPE);//todo retrieved is always null ??
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id, process id", vspId, componentId,
-        processId);
+        VspDetails.ENTITY_TYPE);
   }
 
   private void validateProcessArtifactExistence(String vspId, Version version, String componentId,
                                                 String processId, ProcessEntity retrieved) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id, component id, process id", vspId, componentId,
-        processId);
-
-    if (retrieved != null) {
-      VersioningUtil.validateEntityExistence(retrieved.getArtifact(),
-          new ProcessEntity(vspId, version, componentId, processId),
-          VspDetails.ENTITY_TYPE);
-    } else {
-      VersioningUtil.validateEntityExistence(retrieved,
-          new ProcessEntity(vspId, version, componentId, processId),
-          VspDetails.ENTITY_TYPE); //todo retrieved is always null ??
+    ProcessEntity inputProcess = new ProcessEntity(vspId, version, componentId, processId);
+    VersioningUtil.validateEntityExistence(retrieved, inputProcess, VspDetails.ENTITY_TYPE);
+    if (retrieved.getArtifact() == null) {
+      throw new CoreException(new ErrorCode.ErrorCodeBuilder()
+          .withCategory(ErrorCategory.APPLICATION)
+          .withId(VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND)
+          .withMessage(String.format(PROCESS_ARTIFACT_NOT_EXIST_MSG,
+              processId, VspDetails.ENTITY_TYPE, vspId, version)).build());
     }
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id, component id, process id", vspId, componentId,
-        processId);
   }
 
 
   protected void validateUniqueName(String vspId, Version version, String componentId,
                                     String processName) {
     UniqueValueUtil.validateUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME,
-        vspId, version.toString(), componentId, processName);
+        vspId, version.getId(), componentId, processName);
   }
 
   protected void createUniqueName(String vspId, Version version, String componentId,
                                   String processName) {
     UniqueValueUtil
         .createUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, vspId,
-            version.toString(), componentId, processName);
+            version.getId(), componentId, processName);
   }
 
   protected void updateUniqueName(String vspId, Version version, String componentId,
                                   String oldProcessName, String newProcessName) {
     UniqueValueUtil
         .updateUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, oldProcessName,
-            newProcessName, vspId, version.toString(), componentId);
+            newProcessName, vspId, version.getId(), componentId);
   }
 
   protected void deleteUniqueValue(String vspId, Version version, String componentId,
                                    String processName) {
+    if (componentId == null) {
+      UniqueValueUtil
+          .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, vspId,
+              version.getId(), processName);
+    }
     UniqueValueUtil
         .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME, vspId,
-            version.toString(), componentId, processName);
+            version.getId(), componentId, processName);
   }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImpl.java
index d4879da8d7..640d5c00c7 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImpl.java
@@ -34,18 +34,12 @@ import org.openecomp.core.utilities.json.JsonUtil;
 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
 import org.openecomp.core.validation.api.ValidationManager;
 import org.openecomp.core.validation.util.MessageContainerUtil;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
-import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.common.errors.ValidationErrorBuilder;
 import org.openecomp.sdc.common.utils.CommonUtil;
-import org.openecomp.sdc.common.utils.SdcCommon;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
 import org.openecomp.sdc.datatypes.error.ErrorMessage;
-import org.openecomp.sdc.generator.datatypes.tosca.VspModelInfo;
-import org.openecomp.sdc.healing.api.HealingManager;
 import org.openecomp.sdc.logging.api.Logger;
 import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
@@ -63,11 +57,14 @@ import org.openecomp.sdc.vendorlicense.licenseartifacts.VendorLicenseArtifactsSe
 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.errors.VendorSoftwareProductNotFoundErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
@@ -76,18 +73,17 @@ import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.UploadDataEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspQuestionnaireEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentDependencyModelErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentErrorBuilder;
-import org.openecomp.sdc.vendorsoftwareproduct.errors.CreatePackageForNonFinalVendorSoftwareProductErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.DeploymentFlavorErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.FileCreationErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.InformationArtifactCreationErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.NicInternalNetworkErrorBuilder;
-import org.openecomp.sdc.vendorsoftwareproduct.errors.OnboardingMethodErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageInvalidErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.PackageNotFoundErrorBuilder;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.TranslationFileCreationErrorBuilder;
@@ -99,7 +95,6 @@ import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGe
 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireValidationResult;
 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.VersionedVendorSoftwareProductInfo;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityId;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
@@ -111,15 +106,8 @@ import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentQu
 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateInput;
 import org.openecomp.sdc.vendorsoftwareproduct.utils.ComponentDependencyTracker;
-import org.openecomp.sdc.versioning.VersioningManager;
 import org.openecomp.sdc.versioning.VersioningUtil;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.dao.types.VersionStatus;
-import org.openecomp.sdc.versioning.errors.RequestedVersionInvalidErrorBuilder;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
-import org.openecomp.sdcrests.activitylog.types.ActivityType;
-import org.slf4j.MDC;
 
 import java.io.BufferedOutputStream;
 import java.io.ByteArrayInputStream;
@@ -136,276 +124,178 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.Set;
 import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;
 
 public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductManager {
-  private String VALIDATION_VSP_ID = "validationOnlyVspId";
-  private static final String VALIDATION_VSP_NAME = "validationOnlyVspName";
-  //private static final String VALIDATION_VSP_USER = "validationOnlyVspUser";
-
-  private static final MdcDataDebugMessage MDC_DATA_DEBUG_MESSAGE = new MdcDataDebugMessage();
+  private static MdcDataDebugMessage MDC_DATA_DEBUG_MESSAGE = new MdcDataDebugMessage();
   private static final Logger LOGGER =
       LoggerFactory.getLogger(VendorSoftwareProductManagerImpl.class);
 
-  private final OrchestrationTemplateDao orchestrationTemplateDao;
-  private final VendorSoftwareProductInfoDao vspInfoDao;
-  private final VersioningManager versioningManager;
-  private final VendorSoftwareProductDao vendorSoftwareProductDao;
-  private final VendorLicenseFacade vendorLicenseFacade;
-  private final ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
-  private final EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao;
-  private final HealingManager healingManager;
-  private final VendorLicenseArtifactsService licenseArtifactsService;
-  private final InformationArtifactGenerator informationArtifactGenerator;
-  private final PackageInfoDao packageInfoDao;
-  private final ActivityLogManager activityLogManager;
-  private final DeploymentFlavorDao deploymentFlavorDao;
-  private final NicDao nicDao;
-  private final ManualVspToscaManager manualVspToscaManager;
-
-  /**
-   * Instantiates a new Vendor software product manager.
-   *
-   * @param versioningManager            the versioning manager
-   * @param vendorSoftwareProductDao     the vendor software product dao
-   * @param orchestrationTemplateDataDao the orchestration template data dao
-   * @param vspInfoDao                   the vsp info dao
-   * @param vendorLicenseFacade          the vendor license facade
-   * @param serviceModelDao              the service model dao
-   * @param enrichedServiceModelDao      the enriched service model dao
-   * @param healingManager               the healing manager
-   * @param licenseArtifactsService      the license artifacts service
-   * @param informationArtifactGenerator the information artifact generator
-   * @param packageInfoDao               the package info dao
-   * @param activityLogManager           the activity log manager
-   * @param deploymentFlavorDao          the deployment flavor dao
-   * @param nicDao                       the nic dao
-   */
+  private OrchestrationTemplateDao orchestrationTemplateDao;
+  private VendorSoftwareProductInfoDao vspInfoDao;
+  private VendorLicenseFacade vendorLicenseFacade;
+  private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao;
+  private EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao;
+  private VendorLicenseArtifactsService licenseArtifactsService;
+  private InformationArtifactGenerator informationArtifactGenerator;
+  private PackageInfoDao packageInfoDao;
+  private DeploymentFlavorDao deploymentFlavorDao;
+  private ComponentDao componentDao;
+  private ComponentDependencyModelDao componentDependencyModelDao;
+  private NicDao nicDao;
+  private ComputeDao computeDao;
+  private ImageDao imageDao;
+  private ManualVspToscaManager manualVspToscaManager;
+
   public VendorSoftwareProductManagerImpl(
-      VersioningManager versioningManager,
-      VendorSoftwareProductDao vendorSoftwareProductDao,
       OrchestrationTemplateDao orchestrationTemplateDataDao,
       VendorSoftwareProductInfoDao vspInfoDao,
       VendorLicenseFacade vendorLicenseFacade,
       ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDao,
       EnrichedServiceModelDao<ToscaServiceModel, ServiceElement> enrichedServiceModelDao,
-      HealingManager healingManager,
       VendorLicenseArtifactsService licenseArtifactsService,
       InformationArtifactGenerator informationArtifactGenerator,
       PackageInfoDao packageInfoDao,
-      ActivityLogManager activityLogManager,
       DeploymentFlavorDao deploymentFlavorDao,
+      ComponentDao componentDao,
+      ComponentDependencyModelDao componentDependencyModelDao,
       NicDao nicDao,
+      ComputeDao computeDao,
+      ImageDao imageDao,
       ManualVspToscaManager manualVspToscaManager) {
-    this.versioningManager = versioningManager;
-    this.vendorSoftwareProductDao = vendorSoftwareProductDao;
     this.orchestrationTemplateDao = orchestrationTemplateDataDao;
     this.vspInfoDao = vspInfoDao;
     this.vendorLicenseFacade = vendorLicenseFacade;
     this.serviceModelDao = serviceModelDao;
     this.enrichedServiceModelDao = enrichedServiceModelDao;
-    this.healingManager = healingManager;
     this.licenseArtifactsService = licenseArtifactsService;
     this.informationArtifactGenerator = informationArtifactGenerator;
     this.packageInfoDao = packageInfoDao;
-    this.activityLogManager = activityLogManager;
     this.deploymentFlavorDao = deploymentFlavorDao;
+    this.componentDao = componentDao;
+    this.componentDependencyModelDao = componentDependencyModelDao;
     this.nicDao = nicDao;
+    this.computeDao = computeDao;
+    this.imageDao = imageDao;
     this.manualVspToscaManager = manualVspToscaManager;
 
     registerToVersioning();
   }
 
   private void registerToVersioning() {
-    vendorSoftwareProductDao.registerVersioning(
-        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
     serviceModelDao.registerVersioning(
         VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
     enrichedServiceModelDao.registerVersioning(
         VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE);
   }
 
-  @Override
-  public Version checkout(String vendorSoftwareProductId, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vendorSoftwareProductId);
-    MDC.put(LoggerConstants.SERVICE_NAME, LoggerServiceName.Checkout_Entity.toString());
-
-    Version newVersion = versioningManager
-        .checkout(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-            vendorSoftwareProductId, user);
-
-    if (newVersion != null) {
-      ActivityLogEntity activityLogEntity =
-          new ActivityLogEntity(vendorSoftwareProductId, String.valueOf(newVersion.getMajor() + 1),
-              ActivityType.CHECKOUT.toString(), user, true, "", "");
-      activityLogManager.addActionLog(activityLogEntity, user);
-    }
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vendorSoftwareProductId);
-    return newVersion;
-  }
-
-
-  @Override
-  public Version undoCheckout(String vendorSoftwareProductId, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vendorSoftwareProductId);
-
-    Version version =
-        getVersionInfo(vendorSoftwareProductId, VersionableEntityAction.Read, user)
-            .getActiveVersion();
-
-    ActivityLogEntity activityLogEntity =
-        new ActivityLogEntity(vendorSoftwareProductId, String.valueOf(version.getMajor() + 1),
-            ActivityType.UNDO_CHECKOUT.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-
-    String preVspName = vspInfoDao
-        .get(new VspDetails(vendorSoftwareProductId, version)).getName();
-
-    Version newVersion = versioningManager.undoCheckout(
-        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-        vendorSoftwareProductId, user);
-
-    String postVspName = vspInfoDao
-        .get(new VspDetails(vendorSoftwareProductId, newVersion))
-        .getName();
-
-    updateUniqueName(preVspName, postVspName);
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vendorSoftwareProductId);
-
-    return newVersion;
-  }
 
   @Override
-  public Version checkin(String vendorSoftwareProductId, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vendorSoftwareProductId);
-
-    Version newVersion = versioningManager.checkin(
-        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-        vendorSoftwareProductId, user, null);
-
-    if (newVersion != null) {
-      ActivityLogEntity activityLogEntity =
-          new ActivityLogEntity(vendorSoftwareProductId, String.valueOf(newVersion.getMajor() + 1),
-              ActivityType.CHECKIN.toString(), user, true, "", "");
-      activityLogManager.addActionLog(activityLogEntity, user);
-    }
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vendorSoftwareProductId);
-
-    return newVersion;
-  }
-
-  @Override
-  public ValidationResponse submit(String vspId, String user) throws IOException {
+  public ValidationResponse validate(String vspId, Version version) throws IOException {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
 
-    Version version = getVersionInfo(vspId, VersionableEntityAction.Read, user).getActiveVersion();
-    VspDetails vspDetails = getVsp(vspId, version, user);
-    UploadDataEntity uploadData = orchestrationTemplateDao.getOrchestrationTemplate(vspId, version);
-    ToscaServiceModel serviceModel =
-        serviceModelDao.getServiceModel(vspId, vspDetails.getVersion());
+    VspDetails vspDetails = getValidatedVsp(vspId, version);
+    Collection<ComponentDependencyModelEntity> componentDependencies =
+        componentDependencyModelDao.list(new ComponentDependencyModelEntity(vspId, version, null));
 
     ValidationResponse validationResponse = new ValidationResponse();
-    validationResponse
-        .setVspErrors(validateCompletedVendorSoftwareProduct(vspDetails, uploadData, serviceModel),
-            LoggerServiceName.Submit_VSP, LoggerTragetServiceName.SUBMIT_VSP);
-
-    if (isCyclicDependencyInComponents(vspId, vspDetails.getVersion())) {
-      Collection<ErrorCode> vspErrors = validationResponse.getVspErrors() == null
-          ? new ArrayList<>()
-          : validationResponse.getVspErrors();
-      vspErrors.add(ComponentDependencyModelErrorBuilder
-          .getcyclicDependencyComponentErrorBuilder());
-      validationResponse.setVspErrors(vspErrors, LoggerServiceName.Submit_VSP,
-          LoggerTragetServiceName.SUBMIT_VSP);
-    }
-
-    validationResponse.setLicensingDataErrors(validateLicensingData(vspDetails));
-    validationResponse
-        .setUploadDataErrors(validateUploadData(uploadData, vspDetails),
-            LoggerServiceName.Submit_VSP,
-            LoggerTragetServiceName.SUBMIT_VSP);
-
     validationResponse.setQuestionnaireValidationResult(
-        validateQuestionnaire(vspDetails.getId(), vspDetails.getVersion(), vspDetails
-            .getOnboardingMethod()));
-
-    if ("Manual".equals(vspDetails.getOnboardingMethod())) {
-      Collection<ErrorCode> deploymentFlavourValidationErrList =
-          deploymentFlavorValidation(vspDetails.getId(), vspDetails.getVersion());
-      if (validationResponse.getVspErrors() != null) {
-        if (deploymentFlavourValidationErrList != null) {
-          validationResponse.getVspErrors().addAll(deploymentFlavourValidationErrList);
-        }
-      } else {
-        validationResponse
-            .setVspErrors(deploymentFlavourValidationErrList, LoggerServiceName.Submit_VSP,
-                LoggerTragetServiceName.SUBMIT_VSP);
+        validateQuestionnaire(vspDetails.getId(), vspDetails.getVersion(),
+            vspDetails.getOnboardingMethod()));
+
+    List<ErrorCode> vspErrors = new ArrayList<>();
+    vspErrors.addAll(validateVspFields(vspDetails));
+    if (validateComponentDependencies(componentDependencies)) {
+      vspErrors
+          .add(ComponentDependencyModelErrorBuilder.getcyclicDependencyComponentErrorBuilder());
+    }
+    if (Objects.nonNull(vspDetails.getOnboardingMethod()) &&
+        OnboardingMethod.Manual.name().equals(vspDetails.getOnboardingMethod())) {
+      vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
+
+      Collection<DeploymentFlavorEntity> deploymentFlavors = deploymentFlavorDao
+          .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails.getVersion(), null));
+      if (CollectionUtils.isEmpty(deploymentFlavors)) {
+        vspErrors
+            .add(VendorSoftwareProductInvalidErrorBuilder.VspMissingDeploymentFlavorErrorBuilder());
       }
+      vspErrors.addAll(validateDeploymentFlavors(deploymentFlavors));
 
-      Set<CompositionEntityValidationData> compositionEntityValidationData =
+      Set<CompositionEntityValidationData> componentValidationResult =
           componentValidation(vspDetails.getId(), vspDetails.getVersion());
-      if (validationResponse.getQuestionnaireValidationResult() != null) {
-        if (!CollectionUtils.isEmpty(compositionEntityValidationData)) {
+      if (!CollectionUtils.isEmpty(componentValidationResult)) {
+        if (validationResponse.getQuestionnaireValidationResult() == null ||
+            validationResponse.getQuestionnaireValidationResult().getValidationData() == null) {
+          validationResponse.setQuestionnaireValidationResult(
+              new QuestionnaireValidationResult(componentValidationResult));
+        } else {
           validationResponse.getQuestionnaireValidationResult().getValidationData()
-              .addAll(compositionEntityValidationData);
+              .addAll(componentValidationResult);
         }
-      } else {
-        validationResponse.setQuestionnaireValidationResult(
-            CollectionUtils.isEmpty(compositionEntityValidationData) ? null :
-                new QuestionnaireValidationResult(compositionEntityValidationData));
       }
-
-      //Generate Tosca service model for Manual Onboarding flow
-      VspModelInfo vspModelInfo = manualVspToscaManager.gatherVspInformation(vspId, version, user);
-      serviceModel = manualVspToscaManager.generateToscaModel(vspModelInfo);
-    }
-    validationResponse.setCompilationErrors(
-        compile(vspId, vspDetails.getVersion(), serviceModel),
-        LoggerServiceName.Submit_VSP, LoggerTragetServiceName.SUBMIT_VSP);
-
-    if (validationResponse.isValid()) {
-      Version newVersion = versioningManager.submit(
-          VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-          vspId, user, null);
-      ActivityLogEntity activityLogEntity = new ActivityLogEntity(vspDetails.getId(), String
-          .valueOf(newVersion.getMajor()),
-          ActivityType.SUBMIT.toString(), user, true, "", "");
-      activityLogManager.addActionLog(activityLogEntity, user);
+    } else {
+      if (vspDetails.getVlmVersion() != null || vspDetails.getLicenseAgreement() != null
+          || vspDetails.getFeatureGroups() != null) {
+        vspErrors.addAll(validateMandatoryLicenseFields(vspDetails));
+      }
+      OrchestrationTemplateEntity orchestrationTemplate =
+          orchestrationTemplateDao.get(vspId, version);
+      ToscaServiceModel serviceModel =
+          serviceModelDao.getServiceModel(vspId, vspDetails.getVersion());
+      if (!isOrchestrationTemplateExist(orchestrationTemplate) ||
+          !isServiceModelExist(serviceModel)) {
+        vspErrors.add(VendorSoftwareProductInvalidErrorBuilder
+            .VendorSoftwareProductMissingServiceModelErrorBuilder(vspDetails.getId(),
+                vspDetails.getVersion()));
+      }
+      validationResponse.setUploadDataErrors(validateOrchestrationTemplate(orchestrationTemplate),
+          LoggerServiceName.Submit_VSP, LoggerTragetServiceName.SUBMIT_VSP);
     }
+    validationResponse
+        .setVspErrors(vspErrors, LoggerServiceName.Submit_VSP, LoggerTragetServiceName.SUBMIT_VSP);
+    validationResponse.setLicensingDataErrors(validateLicensingData(vspDetails));
+
 
     MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vspId);
     return validationResponse;
   }
 
-  private boolean isCyclicDependencyInComponents(String vendorSoftwareProductId,
-                                                 Version version) {
-    final Collection<ComponentDependencyModelEntity> componentDependencyModelEntities =
-        vendorSoftwareProductDao.listComponentDependencies(vendorSoftwareProductId, version);
+  @Override
+  public Map<String, List<ErrorMessage>> compile(String vspId, Version version) {
+    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
+
+    ToscaServiceModel serviceModel =
+        OnboardingMethod.Manual.name().equals(getValidatedVsp(vspId, version).getOnboardingMethod())
+            //Generate Tosca service model for Manual Onboarding flow
+            ? manualVspToscaManager
+            .generateToscaModel(manualVspToscaManager.gatherVspInformation(vspId, version))
+            : serviceModelDao.getServiceModel(vspId, version);
+
+    Map<String, List<ErrorMessage>> compilationErrors = compile(vspId, version, serviceModel);
+    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vspId);
+    return compilationErrors;
+  }
+
+  private boolean validateComponentDependencies(
+      Collection<ComponentDependencyModelEntity> componentDependencies) {
     ComponentDependencyTracker dependencyTracker = new ComponentDependencyTracker();
 
-    for (ComponentDependencyModelEntity entity : componentDependencyModelEntities) {
-      dependencyTracker.addDependency(entity.getSourceComponentId(), entity.getTargetComponentId());
+    for (ComponentDependencyModelEntity componentDependency : componentDependencies) {
+      dependencyTracker.addDependency(componentDependency.getSourceComponentId(),
+          componentDependency.getTargetComponentId());
     }
     return dependencyTracker.isCyclicDependencyPresent();
   }
 
-  private Collection<ErrorCode> deploymentFlavorValidation(String vspId,
-                                                           Version version) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
-    Set<CompositionEntityValidationData> validationData = new HashSet<>();
+  private Collection<ErrorCode> validateDeploymentFlavors(
+      Collection<DeploymentFlavorEntity> deploymentFlavors) {
+
     Collection<ErrorCode> errorCodeList = new ArrayList<>();
-    Collection<DeploymentFlavorEntity> deploymentFlavors =
-        vendorSoftwareProductDao.listDeploymentFlavors(vspId, version);
     if (!CollectionUtils.isEmpty(deploymentFlavors)) {
       deploymentFlavors.forEach(deploymentFlavor -> {
-        DeploymentFlavorEntity deployment = vendorSoftwareProductDao.getDeploymentFlavor(vspId,
-            version, deploymentFlavor.getId());
+        DeploymentFlavorEntity deployment = deploymentFlavorDao.get(deploymentFlavor);
         DeploymentFlavor deploymentlocalFlavor = deployment.getDeploymentFlavorCompositionData();
         if (deploymentlocalFlavor != null) {
           if (deploymentlocalFlavor.getFeatureGroupId() == null) {
@@ -455,7 +345,7 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
 
     Set<CompositionEntityValidationData> validationData = new HashSet<>();
     Collection<ComponentEntity> components =
-        vendorSoftwareProductDao.listComponents(vspId, version);
+        componentDao.list(new ComponentEntity(vspId, version, null));
     if (!CollectionUtils.isEmpty(components)) {
       components.forEach(component -> {
         validateImage(vspId, version, validationData, component);
@@ -496,13 +386,13 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   private void validateImage(String vspId, Version version,
                              Set<CompositionEntityValidationData> validationData,
                              ComponentEntity component) {
-    Collection<ImageEntity> images = vendorSoftwareProductDao.listImages(vspId, version,
-        component.getId());
+    Collection<ImageEntity> images =
+        imageDao.list(new ImageEntity(vspId, version, component.getId(), null));
     if (CollectionUtils.isEmpty(images)) {
       CompositionEntityValidationData compositionEntityValidationData = new
           CompositionEntityValidationData(component.getType(), component.getId());
-      compositionEntityValidationData.setEntityName(component.getComponentCompositionData()
-          .getDisplayName());
+      compositionEntityValidationData
+          .setEntityName(component.getComponentCompositionData().getDisplayName());
       ErrorCode vfcMissingImageErrorBuilder =
           ComponentErrorBuilder.VfcMissingImageErrorBuilder();
       List<String> errors = new ArrayList<>();
@@ -512,10 +402,7 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     }
   }
 
-
-  private List<ErrorCode> validateCompletedVendorSoftwareProduct(
-      VspDetails vspDetails, UploadDataEntity uploadData, Object serviceModel) {
-
+  private List<ErrorCode> validateVspFields(VspDetails vspDetails) {
     List<ErrorCode> errors = new ArrayList<>();
 
     if (vspDetails.getName() == null) {
@@ -533,36 +420,13 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     if (vspDetails.getSubCategory() == null) {
       errors.add(createMissingMandatoryFieldError("sub category"));
     }
-    if ("Manual".equals(vspDetails.getOnboardingMethod())) {
-      //Manual Onboarding specific validations
-      Collection<DeploymentFlavorEntity> deploymentFlavorEntities = vendorSoftwareProductDao
-          .listDeploymentFlavors(vspDetails.getId(), vspDetails.getVersion());
-      if (CollectionUtils.isEmpty(deploymentFlavorEntities)) {
-        ErrorCode vspMissingDeploymentFlavorErrorBuilder =
-            VendorSoftwareProductInvalidErrorBuilder.VspMissingDeploymentFlavorErrorBuilder();
-        errors.add(vspMissingDeploymentFlavorErrorBuilder);
-      }
-      errors.addAll(validateMandatoryLicenseFields(vspDetails));
-    } else {
-      //Heat flow specific VSP validations
-      if (uploadData == null || uploadData.getContentData() == null || serviceModel == null) {
-        errors.add(VendorSoftwareProductInvalidErrorBuilder
-            .VendorSoftwareProductMissingServiceModelErrorBuilder(vspDetails.getId(),
-                vspDetails.getVersion()));
-      }
-      if (vspDetails.getVlmVersion() != null || vspDetails.getLicenseAgreement() != null
-          || vspDetails.getFeatureGroups() != null) {
-        errors.addAll(validateMandatoryLicenseFields(vspDetails));
-      }
-    }
-    return errors.isEmpty() ? null : errors;
+    return errors;
   }
 
   private List<ErrorCode> validateMandatoryLicenseFields(VspDetails vspDetails) {
     List<ErrorCode> errors = new ArrayList<>();
     if (vspDetails.getVlmVersion() == null) {
-      errors.add(createMissingMandatoryFieldError(
-          "licensing version (in the format of: {integer}.{integer})"));
+      errors.add(createMissingMandatoryFieldError("licensing version"));
     }
     if (vspDetails.getLicenseAgreement() == null) {
       errors.add(createMissingMandatoryFieldError("license agreement"));
@@ -577,23 +441,9 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     return new ValidationErrorBuilder("must be supplied", fieldName).build();
   }
 
-  String getVspQuestionnaireSchema(SchemaTemplateInput schemaInput) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage(null);
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage(null);
-    return SchemaGenerator
-        .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, schemaInput);
-  }
-
-  private static void sortVspListByModificationTimeDescOrder(
-      List<VersionedVendorSoftwareProductInfo> vsps) {
-    vsps.sort((o1, o2) -> o2.getVspDetails().getWritetimeMicroSeconds()
-        .compareTo(o1.getVspDetails().getWritetimeMicroSeconds()));
-  }
-
-
   private Map<String, List<ErrorMessage>> compile(String vendorSoftwareProductId, Version version,
                                                   ToscaServiceModel serviceModel) {
-    if (serviceModel == null) {
+    if (!isServiceModelExist(serviceModel)) {
       return null;
     }
 
@@ -636,135 +486,47 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   }
 
   @Override
-  public String fetchValidationVsp(String user) {
-    try {
-      validateUniqueName(VALIDATION_VSP_NAME);
-    } catch (Exception ignored) {
-      LOGGER.debug("Ignored exception when validating unique VSP name", ignored);
-      return VALIDATION_VSP_ID;
-    }
-    VspDetails validationVsp = new VspDetails();
-    validationVsp.setName(VALIDATION_VSP_NAME);
-
-    vspInfoDao.create(validationVsp);
-    Version version = versioningManager.create(
-        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-        validationVsp.getId(), user);
-    validationVsp.setVersion(version);
-
-    createUniqueName(VALIDATION_VSP_NAME);
-    VALIDATION_VSP_ID = validationVsp.getId();
-    return VALIDATION_VSP_ID;
-  }
-
-  @Override
-  public VspDetails createVsp(VspDetails vspDetails, String user) {
+  public VspDetails createVsp(VspDetails vspDetails) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage(null);
 
-    validateUniqueName(vspDetails.getName());
-
-    vspDetails.setOnboardingOrigin(OnboardingTypesEnum.NONE.toString());
-
-    vspInfoDao.create(vspDetails);//id will be set in the dao
-    vspInfoDao.updateQuestionnaireData(vspDetails.getId(), null,
+    vspInfoDao.create(vspDetails);
+    vspInfoDao.updateQuestionnaireData(vspDetails.getId(), vspDetails.getVersion(),
         new JsonSchemaDataGenerator(getVspQuestionnaireSchema(null)).generateData());
 
-    Version version = versioningManager
-        .create(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-            vspDetails.getId(), user);
-    vspDetails.setVersion(version);
-    ActivityLogEntity activityLogEntity = new ActivityLogEntity(vspDetails.getId(), String
-        .valueOf(vspDetails.getVersion().getMajor() + 1),
-        ActivityType.CREATE_NEW.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-    String vspName = vspDetails.getName();
-    createUniqueName(vspName);
     MDC_DATA_DEBUG_MESSAGE.debugExitMessage(null);
     return vspDetails;
   }
 
   @Override
-  public List<VersionedVendorSoftwareProductInfo> listVsps(String versionFilter, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage(null);
-
-    Map<String, VersionInfo> idToVersionsInfo = versioningManager.listEntitiesVersionInfo(
-        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, user,
-        VersionableEntityAction.Read);
-
-    List<VersionedVendorSoftwareProductInfo> vsps = new ArrayList<>();
-    for (Map.Entry<String, VersionInfo> entry : idToVersionsInfo.entrySet()) {
-      VersionInfo versionInfo = entry.getValue();
-      if (versionFilter != null && versionFilter.equals(VersionStatus.Final.name())) {
-        if (versionInfo.getLatestFinalVersion() == null) {
-          continue;
-        }
-        versionInfo.setActiveVersion(versionInfo.getLatestFinalVersion());
-        versionInfo.setStatus(VersionStatus.Final);
-        versionInfo.setLockingUser(null);
-      }
-
-      Version version = versionInfo.getActiveVersion();
-      if (user.equals(versionInfo.getLockingUser())) {
-        version.setStatus(VersionStatus.Locked);
-      }
-      try {
-        VspDetails vsp = vspInfoDao.get(new VspDetails(entry.getKey(), version));
-        if (vsp != null && !vsp.getId().equals(VALIDATION_VSP_ID)) {
-          vsp.setValidationDataStructure(null);
-          vsps.add(new VersionedVendorSoftwareProductInfo(vsp, versionInfo));
-        }
-      } catch (RuntimeException rte) {
-        LOGGER.error(
-            "Error trying to retrieve vsp[" + entry.getKey() + "] version[" + version.toString
-                () + "] " +
-                "message:" + rte.getMessage(), rte);
-      }
-    }
-
-    sortVspListByModificationTimeDescOrder(vsps);
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage(null);
-
-    return vsps;
-  }
-
-  @Override
-  public void updateVsp(VspDetails vspDetails, String user) {
+  public void updateVsp(VspDetails vspDetails) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspDetails.getId());
 
     VspDetails retrieved = vspInfoDao.get(vspDetails);
-    if (!Objects.equals(retrieved.getOnboardingMethod(), vspDetails.getOnboardingMethod())) {
-      final ErrorCode onboardingMethodUpdateErrorCode = OnboardingMethodErrorBuilder
-          .getOnboardingUpdateError();
-
-      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-          LoggerTragetServiceName.UPDATE_VSP, ErrorLevel.ERROR.name(),
-          LoggerErrorCode.DATA_ERROR.getErrorCode(), onboardingMethodUpdateErrorCode.message());
-
-      throw new CoreException(onboardingMethodUpdateErrorCode);
+    // TODO: 6/21/2017 remove this validation when validation will be added in the REST level
+    if (retrieved == null) {
+      throw new RuntimeException(String.format("Vsp with id %s and version %s does not exist.",
+          vspDetails.getId(), vspDetails.getVersion().getId()));
     }
+    vspDetails.setOnboardingMethod(retrieved.getOnboardingMethod());
 
     //If any existing feature group is removed from VSP which is also associated in DF then
     //update DF to remove feature group associations.
-    updateDeploymentFlavor(vspDetails, user);
+    updateDeploymentFlavor(vspDetails);
 
     updateUniqueName(retrieved.getName(), vspDetails.getName());
-    vspDetails.setOldVersion(retrieved.getOldVersion());
-
     vspInfoDao.update(vspDetails);
-    //vendorSoftwareProductDao.updateVspLatestModificationTime(vspDetails.getId(), activeVersion);
 
     MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vspDetails.getId());
   }
 
-  private void updateDeploymentFlavor(VspDetails vspDetails, String user) {
+  private void updateDeploymentFlavor(VspDetails vspDetails) {
     final List<String> featureGroups = vspDetails.getFeatureGroups();
     if (featureGroups != null) {
       final Collection<DeploymentFlavorEntity> deploymentFlavorEntities = deploymentFlavorDao
           .list(new DeploymentFlavorEntity(vspDetails.getId(), vspDetails
               .getVersion(), null));
       if (Objects.nonNull(deploymentFlavorEntities)) {
-        deploymentFlavorEntities.forEach(deploymentFlavorEntity -> {
+        for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
           final String featureGroupId =
               deploymentFlavorEntity.getDeploymentFlavorCompositionData().getFeatureGroupId();
           if (!featureGroups.contains(featureGroupId)) {
@@ -773,18 +535,25 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
             deploymentFlavorCompositionData.setFeatureGroupId(null);
             deploymentFlavorEntity.setDeploymentFlavorCompositionData
                 (deploymentFlavorCompositionData);
-            vendorSoftwareProductDao.updateDeploymentFlavor(deploymentFlavorEntity);
+            deploymentFlavorDao.update(deploymentFlavorEntity);
           }
-        });
+        }
       }
     }
   }
 
 
   @Override
-  public VspDetails getVsp(String vspId, Version version, String user) {
+  public VspDetails getVsp(String vspId, Version version) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
 
+    VspDetails vsp = getValidatedVsp(vspId, version);
+
+    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vspId);
+    return vsp;
+  }
+
+  private VspDetails getValidatedVsp(String vspId, Version version) {
     VspDetails vsp = vspInfoDao.get(new VspDetails(vspId, version));
     if (vsp == null) {
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
@@ -792,64 +561,11 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
           LoggerErrorCode.DATA_ERROR.getErrorCode(), "Requested VSP not found");
       throw new CoreException(new VendorSoftwareProductNotFoundErrorBuilder(vspId).build());
     }
-    vsp.setValidationData(orchestrationTemplateDao.getValidationData(vspId, version));
-    if (Objects.isNull(vsp.getOnboardingOrigin())) { //todo should this only be done for non-Manual?
-      vsp.setOnboardingOrigin(OnboardingTypesEnum.ZIP.toString());
-    }
-
-    if (Objects.isNull(vsp.getNetworkPackageName())) {
-      vsp.setNetworkPackageName("Upload File");
-    }
-
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vspId);
     return vsp;
   }
 
   @Override
-  public Version callAutoHeal(String vspId, VersionInfo versionInfo,
-                              VspDetails vendorSoftwareProductInfo, String user)
-      throws Exception {
-    switch (versionInfo.getStatus()) {
-      case Locked:
-        if (user.equals(versionInfo.getLockingUser())) {
-          autoHeal(vspId, versionInfo.getActiveVersion(), vendorSoftwareProductInfo,
-              versionInfo.getLockingUser());
-        }
-        return versionInfo.getActiveVersion();
-      case Available:
-        Version checkoutVersion = checkout(vspId, user);
-        autoHeal(vspId, checkoutVersion, vendorSoftwareProductInfo, user);
-        return checkin(vspId, user);
-      case Final:
-        return healAndAdvanceFinalVersion(vspId, vendorSoftwareProductInfo, user);
-      default:
-        //do nothing
-        break;
-    }
-    return versionInfo.getActiveVersion();
-  }
-
-  public Version healAndAdvanceFinalVersion(String vspId, VspDetails vendorSoftwareProductInfo,
-                                            String user) throws IOException {
-
-    Version checkoutVersion = checkout(vspId, user);
-    autoHeal(vspId, checkoutVersion, vendorSoftwareProductInfo, user);
-    Version checkinVersion = checkin(vspId, user);
-
-    ValidationResponse response = Objects.requireNonNull(submit(vspId, user),
-        "Null response not expected");
-
-    if (!response.isValid()) {
-      return checkinVersion;
-    }
-
-    Version finalVersion = checkinVersion.calculateNextFinal();
-    createPackage(vspId, finalVersion, user);
-    return finalVersion;
-  }
-
-  @Override
-  public void deleteVsp(String vspId, String user) {
+  public void deleteVsp(String vspId) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
 
     MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
@@ -862,88 +578,16 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   }
 
   @Override
-  public void heal(String vspId, Version version, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
-
-    VersionInfo versionInfo = getVersionInfo(vspId, VersionableEntityAction.Read, user);
-
-    version = VersionStatus.Locked.equals(versionInfo.getStatus())
-        ? versionInfo.getActiveVersion()
-        : checkout(vspId, user);
-    version.setStatus(VersionStatus.Locked);
-
-    Optional<String> errorMessages =
-        healingManager.healAll(getHealingParamsAsMap(vspId, version, user));
-
-    VspDetails vspDetails = new VspDetails(vspId, version);
-    vspDetails.setOldVersion(null);
-    vspInfoDao.updateOldVersionIndication(vspDetails);
-
-    LOGGER.audit("Healed VSP " + vspDetails.getId());
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vspId);
-
-    errorMessages.ifPresent(s -> {
-      throw new CoreException(new ErrorCode.ErrorCodeBuilder().withId("HEALING_ERROR")
-              .withCategory(ErrorCategory.APPLICATION).withMessage(s).build());
-    });
-  }
-
-  private void autoHeal(String vspId, Version checkoutVersion, VspDetails vspDetails, String user) {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
-
-    checkoutVersion.setStatus(VersionStatus.Locked);
-    Map<String, Object> healingParams = getHealingParamsAsMap(vspId, checkoutVersion, user);
-
-    Optional<String> errorMessages = healingManager.healAll(healingParams);
-
-    vspDetails.setVersion(checkoutVersion);
-    vspDetails.setOldVersion(null);
-    vspInfoDao.updateOldVersionIndication(vspDetails);
-
-    LOGGER.audit("Healed VSP " + vspDetails.getName());
-    MDC_DATA_DEBUG_MESSAGE.debugExitMessage("VSP id", vspId);
-
-    errorMessages.ifPresent(s -> {
-      throw new CoreException(new ErrorCode.ErrorCodeBuilder().withId("HEALING_ERROR")
-              .withCategory(ErrorCategory.APPLICATION).withMessage(s).build());
-    });
-  }
-
-  private Map<String, Object> getHealingParamsAsMap(String vspId, Version version, String user) {
-    Map<String, Object> healingParams = new HashMap<>();
-
-    healingParams.put(SdcCommon.VSP_ID, vspId);
-    healingParams.put(SdcCommon.VERSION, version);
-    healingParams.put(SdcCommon.USER, user);
-
-    return healingParams;
-  }
-
-  @Override
   public List<PackageInfo> listPackages(String category, String subCategory) {
     return packageInfoDao.listByCategory(category, subCategory);
   }
 
   @Override
-  public File getTranslatedFile(String vspId, Version version, String user) {
+  public File getTranslatedFile(String vspId, Version version) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
     String errorMessage;
-    if (version == null) {
-      errorMessage = "Package not found";
-      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-          LoggerTragetServiceName.GET_TRANSLATED_FILE, ErrorLevel.ERROR.name(),
-          LoggerErrorCode.DATA_ERROR.getErrorCode(), errorMessage);
-      throw new CoreException(new PackageNotFoundErrorBuilder(vspId).build());
-    } else if (!version.isFinal()) {
-      errorMessage = "Invalid requested version";
-      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-          LoggerTragetServiceName.GET_VERSION_INFO, ErrorLevel.ERROR.name(),
-          LoggerErrorCode.DATA_ERROR.getErrorCode(), errorMessage);
-      throw new CoreException(new RequestedVersionInvalidErrorBuilder().build());
-    }
 
-    PackageInfo packageInfo =
-        packageInfoDao.get(new PackageInfo(vspId, version));
+    PackageInfo packageInfo = packageInfoDao.get(new PackageInfo(vspId, version));
     if (packageInfo == null) {
       errorMessage = "Package not found";
       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
@@ -981,10 +625,10 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
 
   @Override
 
-  public byte[] getOrchestrationTemplateFile(String vspId, Version version, String user) {
+  public byte[] getOrchestrationTemplateFile(String vspId, Version version) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
 
-    UploadDataEntity uploadData = orchestrationTemplateDao.getOrchestrationTemplate(vspId, version);
+    OrchestrationTemplateEntity uploadData = orchestrationTemplateDao.get(vspId, version);
     ByteBuffer contentData = uploadData.getContentData();
     if (contentData == null) {
       return null;
@@ -993,7 +637,7 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
     try (final ZipOutputStream zos = new ZipOutputStream(baos);
-         ZipInputStream zipStream = new ZipInputStream(
+         ZipInputStream ignored = new ZipInputStream(
              new ByteArrayInputStream(contentData.array()))) {
       zos.write(contentData.array());
     } catch (IOException exception) {
@@ -1008,29 +652,25 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   }
 
   @Override
-  public PackageInfo createPackage(String vspId, Version version, String user) throws IOException {
-    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
+  public OrchestrationTemplateEntity getOrchestrationTemplateInfo(String vspId, Version version) {
+    return orchestrationTemplateDao.getInfo(vspId, version);
+  }
 
-    if (!version.isFinal()) {
-      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
-          LoggerTragetServiceName.CREATE_PACKAGE, ErrorLevel.ERROR.name(),
-          LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't create package");
-      throw new CoreException(
-          new CreatePackageForNonFinalVendorSoftwareProductErrorBuilder(vspId, version)
-              .build());
-    }
+  @Override
+  public PackageInfo createPackage(String vspId, Version version) throws IOException {
+    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
 
     ToscaServiceModel toscaServiceModel = enrichedServiceModelDao.getServiceModel(vspId, version);
     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
     Version vlmVersion = vspDetails.getVlmVersion();
 
-    PackageInfo packageInfo = createPackageInfo(vspId, vspDetails);
+    PackageInfo packageInfo = createPackageInfo(vspDetails);
 
     ToscaFileOutputServiceCsarImpl toscaServiceTemplateServiceCsar =
         new ToscaFileOutputServiceCsarImpl();
     FileContentHandler licenseArtifacts = licenseArtifactsService
         .createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion,
-            vspDetails.getFeatureGroups(), user);
+            vspDetails.getFeatureGroups());
     //todo add tosca validation here
     packageInfo.setTranslatedFile(ByteBuffer.wrap(
         toscaServiceTemplateServiceCsar.createOutputFile(toscaServiceModel, licenseArtifacts)));
@@ -1043,10 +683,8 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     return packageInfo;
   }
 
-  private PackageInfo createPackageInfo(String vspId, VspDetails vspDetails) {
-    PackageInfo packageInfo = new PackageInfo();
-    packageInfo.setVspId(vspId);
-    packageInfo.setVersion(vspDetails.getVersion());
+  private PackageInfo createPackageInfo(VspDetails vspDetails) {
+    PackageInfo packageInfo = new PackageInfo(vspDetails.getId(), vspDetails.getVersion());
     packageInfo.setVspName(vspDetails.getName());
     packageInfo.setVspDescription(vspDetails.getDescription());
     packageInfo.setCategory(vspDetails.getCategory());
@@ -1059,7 +697,7 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
 
   @Override
 
-  public QuestionnaireResponse getVspQuestionnaire(String vspId, Version version, String user) {
+  public QuestionnaireResponse getVspQuestionnaire(String vspId, Version version) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
 
     VspQuestionnaireEntity retrieved = vspInfoDao.getQuestionnaire(vspId, version);
@@ -1078,8 +716,7 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   }
 
   @Override
-  public void updateVspQuestionnaire(String vspId, Version version, String questionnaireData,
-                                     String user) {
+  public void updateVspQuestionnaire(String vspId, Version version, String questionnaireData) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
 
     vspInfoDao.updateQuestionnaireData(vspId, version, questionnaireData);
@@ -1088,21 +725,19 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   }
 
 
-  private Map<String, List<ErrorMessage>> validateUploadData(UploadDataEntity uploadData,
-                                                             VspDetails vspDetails)
-      throws IOException {
+  private Map<String, List<ErrorMessage>> validateOrchestrationTemplate(
+      OrchestrationTemplateEntity orchestrationTemplate) throws IOException {
 
-    Map<String, List<ErrorMessage>> validationErrors = new HashMap<>();
-    if (uploadData == null || uploadData.getContentData() == null) {
+    if (!isOrchestrationTemplateExist(orchestrationTemplate)) {
       return null;
     }
+    Map<String, List<ErrorMessage>> validationErrors = new HashMap<>();
 
-    FileContentHandler fileContentMap =
-        CommonUtil.validateAndUploadFileContent(OnboardingTypesEnum.getOnboardingTypesEnum
-                (vspDetails.getOnboardingOrigin()),
-            uploadData.getContentData().array());
+    FileContentHandler fileContentMap = CommonUtil.validateAndUploadFileContent(
+        OnboardingTypesEnum.getOnboardingTypesEnum(orchestrationTemplate.getFileSuffix()),
+        orchestrationTemplate.getContentData().array());
 
-    if (CommonUtil.isFileOriginFromZip(vspDetails.getOnboardingOrigin())) {
+    if (CommonUtil.isFileOriginFromZip(orchestrationTemplate.getFileSuffix())) {
       ValidationManager validationManager =
           ValidationManagerUtil.initValidationManager(fileContentMap);
       validationErrors.putAll(validationManager.validate());
@@ -1113,14 +748,6 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
             ? null : validationErrors;
   }
 
-  private VersionInfo getVersionInfo(String vendorSoftwareProductId, VersionableEntityAction action,
-                                     String user) {
-    return versioningManager.getEntityVersionInfo(
-        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-        vendorSoftwareProductId, user, action);
-  }
-
-
   private QuestionnaireValidationResult validateQuestionnaire(String vspId, Version version,
                                                               String onboardingMethod) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
@@ -1132,7 +759,7 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     compositionEntityDataManager
         .addEntity(vspInfoDao.getQuestionnaire(vspId, version), null);
 
-    Collection<NicEntity> nics = vendorSoftwareProductDao.listNicsByVsp(vspId, version);
+    Collection<NicEntity> nics = nicDao.listByVsp(vspId, version);
 
     Map<String, List<String>> nicNamesByComponent = new HashMap<>();
     for (NicEntity nicEntity : nics) {
@@ -1147,16 +774,16 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     }
 
     Collection<ComponentEntity> components =
-        vendorSoftwareProductDao.listComponentsCompositionAndQuestionnaire(vspId, version);
+        componentDao.listCompositionAndQuestionnaire(vspId, version);
     components.forEach(component -> compositionEntityDataManager.addEntity(component,
         new ComponentQuestionnaireSchemaInput(nicNamesByComponent.get(component.getId()),
             JsonUtil.json2Object(component.getQuestionnaireData(), Map.class))));
 
-    Collection<ComputeEntity> computes = vendorSoftwareProductDao.listComputesByVsp(vspId, version);
+    Collection<ComputeEntity> computes = computeDao.listByVsp(vspId, version);
     computes.forEach(compute -> compositionEntityDataManager.addEntity(compute, null));
 
-    if ("Manual".equals(onboardingMethod)) {
-      Collection<ImageEntity> images = vendorSoftwareProductDao.listImagesByVsp(vspId, version);
+    if (OnboardingMethod.Manual.name().equals(onboardingMethod)) {
+      Collection<ImageEntity> images = imageDao.listByVsp(vspId, version);
       images.forEach(image -> compositionEntityDataManager.addEntity(image, null));
     }
 
@@ -1179,7 +806,7 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   }
 
   @Override
-  public File getInformationArtifact(String vspId, Version version, String user) {
+  public File getInformationArtifact(String vspId, Version version) {
     MDC_DATA_DEBUG_MESSAGE.debugEntryMessage("VSP id", vspId);
     VspDetails vspDetails = vspInfoDao.get(new VspDetails(vspId, version));
 
@@ -1209,14 +836,11 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
     return infoArtifactFile;
   }
 
-  void validateUniqueName(String vspName) {
-    UniqueValueUtil.validateUniqueValue(
-        VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME, vspName);
-  }
-
-  void createUniqueName(String vspName) {
-    UniqueValueUtil.createUniqueValue(
-        VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME, vspName);
+  String getVspQuestionnaireSchema(SchemaTemplateInput schemaInput) {
+    MDC_DATA_DEBUG_MESSAGE.debugEntryMessage(null);
+    MDC_DATA_DEBUG_MESSAGE.debugExitMessage(null);
+    return SchemaGenerator
+        .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, schemaInput);
   }
 
   void updateUniqueName(String oldVspName, String newVspName) {
@@ -1226,13 +850,22 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
   }
 
   @Override
-  public Collection<ComputeEntity> getComputeByVsp(String vspId, Version version,
-                                                   String user) {
-    return vendorSoftwareProductDao.listComputesByVsp(vspId, version);
+  public Collection<ComputeEntity> getComputeByVsp(String vspId, Version version) {
+    return computeDao.listByVsp(vspId, version);
   }
 
-  private void auditIfContainsErrors(List<ErrorMessage> errorList, String vspId, String auditType) {
+  private boolean isOrchestrationTemplateExist(OrchestrationTemplateEntity orchestrationTemplate) {
+    return orchestrationTemplate != null &&
+        orchestrationTemplate.getContentData() != null &&
+        orchestrationTemplate.getFileSuffix() != null &&
+        orchestrationTemplate.getFileName() != null;
+  }
 
+  private boolean isServiceModelExist(ToscaServiceModel serviceModel) {
+    return serviceModel != null && serviceModel.getEntryDefinitionServiceTemplate() != null;
+  }
+
+  private void auditIfContainsErrors(List<ErrorMessage> errorList, String vspId, String auditType) {
     errorList.forEach(errorMessage -> {
       if (errorMessage.getLevel().equals(ErrorLevel.ERROR)) {
         LOGGER.audit(AuditMessages.AUDIT_MSG + String.format(auditType, errorMessage.getMessage(),
@@ -1240,4 +873,6 @@ public class VendorSoftwareProductManagerImpl implements VendorSoftwareProductMa
       }
     });
   }
+
+
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VspManagerFactoryImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VspManagerFactoryImpl.java
index 5615f8f6b5..a2c0aea423 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VspManagerFactoryImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VspManagerFactoryImpl.java
@@ -22,38 +22,38 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 import org.openecomp.core.model.dao.EnrichedServiceModelDaoFactory;
 import org.openecomp.core.model.dao.ServiceModelDaoFactory;
-import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
-import org.openecomp.sdc.healing.factory.HealingManagerFactory;
 import org.openecomp.sdc.vendorlicense.VendorLicenseArtifactServiceFactory;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
 import org.openecomp.sdc.vendorsoftwareproduct.VspManagerFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.NicDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.factory.InformationArtifactGeneratorFactory;
-import org.openecomp.sdc.versioning.VersioningManagerFactory;
 
 public class VspManagerFactoryImpl extends VspManagerFactory {
   private static final VendorSoftwareProductManager INSTANCE =
       new VendorSoftwareProductManagerImpl(
-          VersioningManagerFactory.getInstance().createInterface(),
-          VendorSoftwareProductDaoFactory.getInstance().createInterface(),
           OrchestrationTemplateDaoFactory.getInstance().createInterface(),
           VendorSoftwareProductInfoDaoFactory.getInstance().createInterface(),
           VendorLicenseFacadeFactory.getInstance().createInterface(),
           ServiceModelDaoFactory.getInstance().createInterface(),
           EnrichedServiceModelDaoFactory.getInstance().createInterface(),
-          HealingManagerFactory.getInstance().createInterface(),
           VendorLicenseArtifactServiceFactory.getInstance().createInterface(),
           InformationArtifactGeneratorFactory.getInstance().createInterface(),
           PackageInfoDaoFactory.getInstance().createInterface(),
-          ActivityLogManagerFactory.getInstance().createInterface(),
           DeploymentFlavorDaoFactory.getInstance().createInterface(),
+          ComponentDaoFactory.getInstance().createInterface(),
+          ComponentDependencyModelDaoFactory.getInstance().createInterface(),
           NicDaoFactory.getInstance().createInterface(),
+          ComputeDaoFactory.getInstance().createInterface(),
+          ImageDaoFactory.getInstance().createInterface(),
           new ManualVspToscaManagerImpl());
 
   @Override
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/BaseOrchestrationTemplateHandler.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/BaseOrchestrationTemplateHandler.java
index c7fb43770d..d20dc07b63 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/BaseOrchestrationTemplateHandler.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/BaseOrchestrationTemplateHandler.java
@@ -14,87 +14,94 @@ import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
 import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
-import org.openecomp.sdc.versioning.dao.types.Version;
 
 import java.io.InputStream;
 import java.util.Optional;
+
 import static org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder.getErrorWithParameters;
+
 public abstract class BaseOrchestrationTemplateHandler implements OrchestrationTemplateFileHandler {
-    protected static final Logger logger =
-            LoggerFactory.getLogger(BaseOrchestrationTemplateHandler.class);
-    protected static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
-
-    @Override
-    public UploadFileResponse upload(String vspId, Version version, InputStream fileToUpload, String user,
-                                     CandidateService candidateService, VspDetails vspDetails) {
-        UploadFileResponse uploadFileResponse = new UploadFileResponse();
-        uploadFileResponse.setOnboardingType(getHandlerType());
-        if (isNotEmptyFileToUpload(fileToUpload, uploadFileResponse, candidateService)) {
-            return uploadFileResponse;
-        }
-
-        byte[] uploadedFileData = FileUtils.toByteArray(fileToUpload);
-        if (isInvalidRawZipData(uploadFileResponse, uploadedFileData, candidateService)) {
-            return uploadFileResponse;
-        }
-
-        Optional<FileContentHandler> optionalContentMap =
-                getFileContentMap(uploadFileResponse, uploadedFileData);
-        if (!optionalContentMap.isPresent()) {
-            logger.error(getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(), getHandlerType().toString()));
-            uploadFileResponse
-                    .addStructureError(
-                            SdcCommon.UPLOAD_FILE,
-                            new ErrorMessage(ErrorLevel.ERROR,
-                                    getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(), getHandlerType().toString())));
-
-            mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-            return uploadFileResponse;
-        }
-
-        if (!MapUtils.isEmpty(uploadFileResponse.getErrors())) {
-
-            mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-            return uploadFileResponse;
-        }
-        if (updateCandidateData(vspId, user, candidateService, vspDetails, uploadFileResponse,
-                uploadedFileData, optionalContentMap))
-            return uploadFileResponse;
-
-        mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-        return uploadFileResponse;
+  protected static final Logger logger =
+      LoggerFactory.getLogger(BaseOrchestrationTemplateHandler.class);
+  protected static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
+
+  @Override
+  public UploadFileResponse upload(VspDetails vspDetails, InputStream fileToUpload,
+                                   String fileSuffix, String networkPackageName,
+                                   CandidateService candidateService) {
+    UploadFileResponse uploadFileResponse = new UploadFileResponse();
+    uploadFileResponse.setOnboardingType(getHandlerType());
+    if (isNotEmptyFileToUpload(fileToUpload, uploadFileResponse, candidateService)) {
+      return uploadFileResponse;
+    }
+
+    byte[] uploadedFileData = FileUtils.toByteArray(fileToUpload);
+    if (isInvalidRawZipData(uploadFileResponse, uploadedFileData, candidateService)) {
+      return uploadFileResponse;
+    }
+
+    Optional<FileContentHandler> optionalContentMap =
+        getFileContentMap(uploadFileResponse, uploadedFileData);
+    if (!optionalContentMap.isPresent()) {
+      logger.error(getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(),
+          getHandlerType().toString()));
+      uploadFileResponse.addStructureError(SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR,
+          getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(),
+              getHandlerType().toString())));
 
+      mdcDataDebugMessage.debugExitMessage("VSP id", vspDetails.getId());
+      return uploadFileResponse;
     }
 
-    protected abstract boolean updateCandidateData(String vspId, String user, CandidateService candidateService,
-                                                   VspDetails vspDetails, UploadFileResponse uploadFileResponse,
-                                                   byte[] uploadedFileData,
-                                                   Optional<FileContentHandler> optionalContentMap);
-
-
-    private boolean isNotEmptyFileToUpload(InputStream fileToUpload,
-                                           UploadFileResponse uploadFileResponse, CandidateService candidateService) {
-        Optional<ErrorMessage> errorMessage =
-                candidateService.validateNonEmptyFileToUpload(fileToUpload);
-        if (errorMessage.isPresent()) {
-            uploadFileResponse.addStructureError(SdcCommon.UPLOAD_FILE, errorMessage.get());
-            return true;
-        }
-        return false;
+    if (!MapUtils.isEmpty(uploadFileResponse.getErrors())) {
+      mdcDataDebugMessage.debugExitMessage("VSP id", vspDetails.getId());
+      return uploadFileResponse;
     }
+    if (updateCandidateData(vspDetails, uploadedFileData, optionalContentMap.get(), fileSuffix,
+        networkPackageName, candidateService, uploadFileResponse)) {
+      return uploadFileResponse;
+    }
+
+    mdcDataDebugMessage.debugExitMessage("VSP id", vspDetails.getId());
+    return uploadFileResponse;
+
+  }
+
+  protected abstract boolean updateCandidateData(VspDetails vspDetails,
+                                                 byte[] uploadedFileData,
+                                                 FileContentHandler contentMap,
+                                                 String fileSuffix,
+                                                 String networkPackageName,
+                                                 CandidateService candidateService,
+                                                 UploadFileResponse uploadFileResponse);
 
-    protected boolean isInvalidRawZipData(UploadFileResponse uploadFileResponse,
-                                        byte[] uploadedFileData, CandidateService candidateService) {
-        Optional<ErrorMessage> errorMessage;
-        errorMessage = candidateService.validateRawZipData(uploadedFileData);
-        if (errorMessage.isPresent()) {
-            uploadFileResponse.addStructureError(SdcCommon.UPLOAD_FILE, errorMessage.get());
-            return true;
-        }
-        return false;
+  private boolean isNotEmptyFileToUpload(InputStream fileToUpload,
+                                         UploadFileResponse uploadFileResponse,
+                                         CandidateService candidateService) {
+    Optional<ErrorMessage> errorMessage =
+        candidateService.validateNonEmptyFileToUpload(fileToUpload);
+    if (errorMessage.isPresent()) {
+      uploadFileResponse.addStructureError(SdcCommon.UPLOAD_FILE, errorMessage.get());
+      return true;
     }
+    return false;
+  }
+
+  protected boolean isInvalidRawZipData(UploadFileResponse uploadFileResponse,
+                                        byte[] uploadedFileData,
+                                        CandidateService candidateService) {
+    Optional<ErrorMessage> errorMessage;
+    errorMessage = candidateService.validateRawZipData(uploadedFileData);
+    if (errorMessage.isPresent()) {
+      uploadFileResponse.addStructureError(SdcCommon.UPLOAD_FILE, errorMessage.get());
+      return true;
+    }
+    return false;
+  }
+
+  public abstract Optional<FileContentHandler> getFileContentMap(
+      UploadFileResponse uploadFileResponse,
+      byte[] uploadedFileData);
 
-    public abstract Optional<FileContentHandler> getFileContentMap(UploadFileResponse uploadFileResponse,
-                                                                   byte[] uploadedFileData);
-    protected abstract OnboardingTypesEnum getHandlerType();
+  protected abstract OnboardingTypesEnum getHandlerType();
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateCSARHandler.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateCSARHandler.java
index db0851cd5f..16147553fe 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateCSARHandler.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateCSARHandler.java
@@ -30,131 +30,139 @@ import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.CS
 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.CSARConstants.MAIN_SERVICE_TEMPLATE_YAML_FILE_NAME;
 
 public class OrchestrationTemplateCSARHandler extends BaseOrchestrationTemplateHandler
-        implements OrchestrationTemplateFileHandler {
-
-
-    @Override
-    public Optional<FileContentHandler> getFileContentMap(UploadFileResponse uploadFileResponse,
-                                                          byte[] uploadedFileData) {
-        FileContentHandler contentMap = null;
-        List<String> folderList = new ArrayList<>();
-        try {
-            Pair<FileContentHandler, List<String>> fileContentMapFromOrchestrationCandidateZip = CommonUtil.getFileContentMapFromOrchestrationCandidateZip(uploadedFileData);
-            contentMap = fileContentMapFromOrchestrationCandidateZip.getKey();
-            folderList = fileContentMapFromOrchestrationCandidateZip.getRight();
-        } catch (IOException exception) {
-            uploadFileResponse.addStructureError(
-                    SdcCommon.UPLOAD_FILE,
-                    new ErrorMessage(ErrorLevel.ERROR, Messages.INVALID_CSAR_FILE.getErrorMessage()));
-        } catch (CoreException coreException) {
-            uploadFileResponse.addStructureError(
-                    SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR, coreException.getMessage()));
-        }
-        validateContent(uploadFileResponse, contentMap, folderList);
-        return Optional.ofNullable(contentMap);
+    implements OrchestrationTemplateFileHandler {
+
+
+  @Override
+  public Optional<FileContentHandler> getFileContentMap(UploadFileResponse uploadFileResponse,
+                                                        byte[] uploadedFileData) {
+    FileContentHandler contentMap = null;
+    List<String> folderList = new ArrayList<>();
+    try {
+      Pair<FileContentHandler, List<String>> fileContentMapFromOrchestrationCandidateZip =
+          CommonUtil.getFileContentMapFromOrchestrationCandidateZip(uploadedFileData);
+      contentMap = fileContentMapFromOrchestrationCandidateZip.getKey();
+      folderList = fileContentMapFromOrchestrationCandidateZip.getRight();
+    } catch (IOException exception) {
+      uploadFileResponse.addStructureError(
+          SdcCommon.UPLOAD_FILE,
+          new ErrorMessage(ErrorLevel.ERROR, Messages.INVALID_CSAR_FILE.getErrorMessage()));
+    } catch (CoreException coreException) {
+      uploadFileResponse.addStructureError(
+          SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR, coreException.getMessage()));
     }
-
-    private void validateContent(UploadFileResponse uploadFileResponse, FileContentHandler contentMap, List<String> folderList) {
-        validateManifest(uploadFileResponse, contentMap);
-        validateFileExist(uploadFileResponse, contentMap, MAIN_SERVICE_TEMPLATE_YAML_FILE_NAME);
-        validateNoExtraFiles(uploadFileResponse, contentMap);
-        validateFolders(uploadFileResponse, folderList);
+    validateContent(uploadFileResponse, contentMap, folderList);
+    return Optional.ofNullable(contentMap);
+  }
+
+  private void validateContent(UploadFileResponse uploadFileResponse, FileContentHandler contentMap,
+                               List<String> folderList) {
+    validateManifest(uploadFileResponse, contentMap);
+    validateFileExist(uploadFileResponse, contentMap, MAIN_SERVICE_TEMPLATE_YAML_FILE_NAME);
+    validateNoExtraFiles(uploadFileResponse, contentMap);
+    validateFolders(uploadFileResponse, folderList);
+  }
+
+  private void validateManifest(UploadFileResponse uploadFileResponse,
+                                FileContentHandler contentMap) {
+
+    if (!validateFileExist(uploadFileResponse, contentMap, MAIN_SERVICE_TEMPLATE_MF_FILE_NAME)) {
+      return;
     }
 
-    private void validateManifest(UploadFileResponse uploadFileResponse, FileContentHandler contentMap) {
-
-        if (!validateFileExist(uploadFileResponse, contentMap, MAIN_SERVICE_TEMPLATE_MF_FILE_NAME)){
-            return;
-        }
-
-        try (InputStream fileContent = contentMap.getFileContent(MAIN_SERVICE_TEMPLATE_MF_FILE_NAME)) {
+    try (InputStream fileContent = contentMap.getFileContent(MAIN_SERVICE_TEMPLATE_MF_FILE_NAME)) {
 
-            OnboardingManifest onboardingManifest = new OnboardingManifest(fileContent);
-            if (!onboardingManifest.isValid()) {
-                onboardingManifest.getErrors().forEach(error -> uploadFileResponse.addStructureError(
-                        SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR, error)));
-            }
+      OnboardingManifest onboardingManifest = new OnboardingManifest(fileContent);
+      if (!onboardingManifest.isValid()) {
+        onboardingManifest.getErrors().forEach(error -> uploadFileResponse.addStructureError(
+            SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR, error)));
+      }
 
-        } catch (IOException e) {
-            // convert to runtime to keep the throws unchanged
-            throw new RuntimeException("Failed to validate manifest", e);
-        }
+    } catch (IOException e) {
+      // convert to runtime to keep the throws unchanged
+      throw new RuntimeException("Failed to validate manifest", e);
     }
-
-    private void validateNoExtraFiles(UploadFileResponse uploadFileResponse,  FileContentHandler contentMap) {
-        List<String> unwantedFiles = contentMap.getFileList().stream()
-                .filter(this::filterFiles).collect(Collectors.toList());
-        if (!unwantedFiles.isEmpty()) {
-            unwantedFiles.stream().filter(this::filterFiles).forEach(unwantedFile ->
-                    uploadFileResponse.addStructureError(
-                            SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR,
-                                    getErrorWithParameters(Messages.CSAR_FILES_NOT_ALLOWED.getErrorMessage(),
-                                            unwantedFile))));
-        }
+  }
+
+  private void validateNoExtraFiles(UploadFileResponse uploadFileResponse,
+                                    FileContentHandler contentMap) {
+    List<String> unwantedFiles = contentMap.getFileList().stream()
+        .filter(this::filterFiles).collect(Collectors.toList());
+    if (!unwantedFiles.isEmpty()) {
+      unwantedFiles.stream().filter(this::filterFiles).forEach(unwantedFile ->
+          uploadFileResponse.addStructureError(
+              SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR,
+                  getErrorWithParameters(Messages.CSAR_FILES_NOT_ALLOWED.getErrorMessage(),
+                      unwantedFile))));
     }
+  }
+
+  private void validateFolders(UploadFileResponse uploadFileResponse, List<String> folderList) {
+    List<String> filterResult =
+        folderList.stream().filter(this::filterFolders).collect(Collectors.toList());
+    if (!filterResult.isEmpty()) {
+      folderList.stream().filter(this::filterFolders).forEach(unwantedFolder ->
+          uploadFileResponse.addStructureError(
+              SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR,
+                  getErrorWithParameters(Messages.CSAR_DIRECTORIES_NOT_ALLOWED.getErrorMessage(),
+                      unwantedFolder))));
 
-    private void validateFolders(UploadFileResponse uploadFileResponse, List<String> folderList) {
-        List<String> filterResult = folderList.stream().filter(this::filterFolders).collect(Collectors.toList());
-        if (!filterResult.isEmpty()) {
-            folderList.stream().filter(this::filterFolders).forEach( unwantedFolder ->
-                    uploadFileResponse.addStructureError(
-                            SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR,
-                                    getErrorWithParameters(Messages.CSAR_DIRECTORIES_NOT_ALLOWED.getErrorMessage(),
-                                            unwantedFolder))));
-
-        }
-    }
-    private boolean filterFiles(String inFileName) {
-        boolean valid = ELIGIBLE_FILES.stream().anyMatch(fileName -> fileName.equals(inFileName));
-        return !valid && filterFolders(inFileName);
     }
+  }
 
-    private boolean filterFolders(String fileName) {
-        return ELIGBLE_FOLDERS.stream().noneMatch(fileName::startsWith);
-    }
+  private boolean filterFiles(String inFileName) {
+    boolean valid = ELIGIBLE_FILES.stream().anyMatch(fileName -> fileName.equals(inFileName));
+    return !valid && filterFolders(inFileName);
+  }
 
-    private boolean validateFileExist(UploadFileResponse uploadFileResponse, FileContentHandler contentMap, String fileName) {
+  private boolean filterFolders(String fileName) {
+    return ELIGBLE_FOLDERS.stream().noneMatch(fileName::startsWith);
+  }
 
-        boolean containsFile = contentMap.containsFile(fileName);
-        if (!containsFile) {
-            uploadFileResponse.addStructureError(
-                    SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR,
-                            getErrorWithParameters(Messages.CSAR_FILE_NOT_FOUND.getErrorMessage(), fileName)));
-        }
-        return containsFile;
-    }
+  private boolean validateFileExist(UploadFileResponse uploadFileResponse,
+                                    FileContentHandler contentMap, String fileName) {
 
-    @Override
-    protected boolean updateCandidateData(String vspId, String user, CandidateService candidateService,
-                                          VspDetails vspDetails, UploadFileResponse uploadFileResponse,
-                                          byte[] uploadedFileData, Optional<FileContentHandler> optionalContentMap) {
-        try {
-            candidateService.updateCandidateUploadData(new OrchestrationTemplateCandidateData(
-                    ByteBuffer.wrap(uploadedFileData), ""), vspDetails.getId());
-        } catch (Exception exception) {
-            logger.error(getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(),
-                    getHandlerType().toString()), exception);
-            uploadFileResponse
-                    .addStructureError(
-                            SdcCommon.UPLOAD_FILE,
-                            new ErrorMessage(ErrorLevel.ERROR, exception.getMessage()));
-
-            mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-            return true;
-        }
-        return false;
+    boolean containsFile = contentMap.containsFile(fileName);
+    if (!containsFile) {
+      uploadFileResponse.addStructureError(
+          SdcCommon.UPLOAD_FILE, new ErrorMessage(ErrorLevel.ERROR,
+              getErrorWithParameters(Messages.CSAR_FILE_NOT_FOUND.getErrorMessage(), fileName)));
     }
-
-
-    @Override
-    protected OnboardingTypesEnum getHandlerType() {
-        return OnboardingTypesEnum.CSAR;
+    return containsFile;
+  }
+
+  @Override
+  protected boolean updateCandidateData(VspDetails vspDetails, byte[] uploadedFileData,
+                                        FileContentHandler contentMap,
+                                        String fileSuffix, String networkPackageName,
+                                        CandidateService candidateService,
+                                        UploadFileResponse uploadFileResponse) {
+    try {
+      candidateService.updateCandidateUploadData(vspDetails.getId(), vspDetails.getVersion(),
+          new OrchestrationTemplateCandidateData(ByteBuffer.wrap(uploadedFileData), "", fileSuffix,
+              networkPackageName));
+    } catch (Exception exception) {
+      logger.error(getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(),
+          getHandlerType().toString()), exception);
+      uploadFileResponse.addStructureError(SdcCommon.UPLOAD_FILE,
+          new ErrorMessage(ErrorLevel.ERROR, exception.getMessage()));
+
+      mdcDataDebugMessage.debugExitMessage("VSP id", vspDetails.getId());
+      return true;
     }
+    return false;
+  }
 
-    @Override
-    protected boolean isInvalidRawZipData(UploadFileResponse uploadFileResponse,
-                                          byte[] uploadedFileData, CandidateService candidateService) {
-        return super.isInvalidRawZipData(uploadFileResponse, uploadedFileData, candidateService);
 
-    }
+  @Override
+  protected OnboardingTypesEnum getHandlerType() {
+    return OnboardingTypesEnum.CSAR;
+  }
+
+  @Override
+  protected boolean isInvalidRawZipData(UploadFileResponse uploadFileResponse,
+                                        byte[] uploadedFileData,
+                                        CandidateService candidateService) {
+    return super.isInvalidRawZipData(uploadFileResponse, uploadedFileData, candidateService);
+  }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateFileHandler.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateFileHandler.java
index 3f7d18de9f..5e006a29bd 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateFileHandler.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateFileHandler.java
@@ -3,10 +3,12 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
 import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
-import org.openecomp.sdc.versioning.dao.types.Version;
 
 import java.io.InputStream;
+
 public interface OrchestrationTemplateFileHandler {
-    UploadFileResponse upload(String vspId, Version version, InputStream fileToUpload, String user,
-                              CandidateService candidateService, VspDetails vspDetails);
+
+  UploadFileResponse upload(VspDetails vspDetails, InputStream fileToUpload,
+                            String fileSuffix, String networkPackageName,
+                            CandidateService candidateService);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateZipHandler.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateZipHandler.java
index 626d941911..343c7460d9 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateZipHandler.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationTemplateZipHandler.java
@@ -15,41 +15,47 @@ import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
 import java.util.Optional;
 
 import static org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder.getErrorWithParameters;
+
 public class OrchestrationTemplateZipHandler extends BaseOrchestrationTemplateHandler
-        implements OrchestrationTemplateFileHandler {
+    implements OrchestrationTemplateFileHandler {
 
-    @Override
-    public  Optional<FileContentHandler> getFileContentMap(UploadFileResponse uploadFileResponse,
-                                                           byte[] uploadedFileData) {
-       return   OrchestrationUtil.getFileContentMap(OnboardingTypesEnum.ZIP, uploadFileResponse, uploadedFileData);
-    }
+  @Override
+  public Optional<FileContentHandler> getFileContentMap(UploadFileResponse uploadFileResponse,
+                                                        byte[] uploadedFileData) {
+    return OrchestrationUtil
+        .getFileContentMap(OnboardingTypesEnum.ZIP, uploadFileResponse, uploadedFileData);
+  }
 
-    @Override
-    protected boolean updateCandidateData(String vspId, String user, CandidateService candidateService,
-                                          VspDetails vspDetails, UploadFileResponse uploadFileResponse,
-                                          byte[] uploadedFileData, Optional<FileContentHandler> optionalContentMap) {
-        try {
-            OrchestrationTemplateCandidateData candidateData =
-                    new CandidateEntityBuilder(candidateService)
-                            .buildCandidateEntityFromZip(vspDetails, uploadedFileData, optionalContentMap.get(),
-                                    uploadFileResponse.getErrors(), user);
-            candidateService.updateCandidateUploadData(candidateData, vspDetails.getId());
-        } catch (Exception exception) {
-            logger.error(getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(),
-                    getHandlerType().toString()),exception);
-            uploadFileResponse
-                    .addStructureError(
-                            SdcCommon.UPLOAD_FILE,
-                            new ErrorMessage(ErrorLevel.ERROR, exception.getMessage()));
-
-            mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-            return true;
-        }
-        return false;
-    }
+  @Override
+  protected boolean updateCandidateData(VspDetails vspDetails, byte[] uploadedFileData,
+                                        FileContentHandler contentMap,
+                                        String fileSuffix, String networkPackageName,
+                                        CandidateService candidateService,
+                                        UploadFileResponse uploadFileResponse) {
+    try {
+      OrchestrationTemplateCandidateData candidateData =
+          new CandidateEntityBuilder(candidateService)
+              .buildCandidateEntityFromZip(vspDetails, uploadedFileData, contentMap,
+                  uploadFileResponse.getErrors());
+      candidateData.setFileSuffix(fileSuffix);
+      candidateData.setFileName(networkPackageName);
 
-    @Override
-    protected OnboardingTypesEnum getHandlerType() {
-        return OnboardingTypesEnum.ZIP;
+      candidateService
+          .updateCandidateUploadData(vspDetails.getId(), vspDetails.getVersion(), candidateData);
+    } catch (Exception exception) {
+      logger.error(getErrorWithParameters(Messages.FILE_CONTENT_MAP.getErrorMessage(),
+          getHandlerType().toString()), exception);
+      uploadFileResponse.addStructureError(SdcCommon.UPLOAD_FILE,
+          new ErrorMessage(ErrorLevel.ERROR, exception.getMessage()));
+
+      mdcDataDebugMessage.debugExitMessage("VSP id", vspDetails.getId());
+      return true;
     }
+    return false;
+  }
+
+  @Override
+  protected OnboardingTypesEnum getHandlerType() {
+    return OnboardingTypesEnum.ZIP;
+  }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUploadFactory.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUploadFactory.java
index 99b311e473..3c3ab81e10 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUploadFactory.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUploadFactory.java
@@ -24,8 +24,8 @@ public class OrchestrationUploadFactory {
 
     }
 
-    public static final OrchestrationTemplateFileHandler createOrchestrationTemplateFileHandler(String filePrefix) {
-        String fileExtension = filePrefix.toLowerCase();
+    public static final OrchestrationTemplateFileHandler createOrchestrationTemplateFileHandler(String fileSuffix) {
+        String fileExtension = fileSuffix.toLowerCase();
         ImplementationConfiguration orchestrationTemplateFileHandler = fileHanlders.get(fileExtension);
 
         if(Objects.isNull(orchestrationTemplateFileHandler)){
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUtil.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUtil.java
index 2ee7b263b9..e312e7c576 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUtil.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/OrchestrationUtil.java
@@ -1,8 +1,5 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration;
 
-import static org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants.GENERAL_COMPONENT_ID;
-import static org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME;
-
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.collections4.MapUtils;
 import org.openecomp.core.model.dao.ServiceModelDao;
@@ -35,14 +32,16 @@ import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentMonitoringUploadEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateCandidateData;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.UploadData;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.factory.CompositionDataExtractorFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.factory.CompositionEntityDataManagerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionDataExtractor;
@@ -62,13 +61,13 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import static org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants.UniqueValues.PROCESS_NAME;
+
 public class OrchestrationUtil {
 
   public static final String ORCHESTRATION_CONFIG_NAMESPACE = "orchestration";
   public static final String ORCHESTRATION_IMPL_KEY = "orchestration_impl";
 
-
-  private VendorSoftwareProductDao vendorSoftwareProductDao;
   private NicDao nicDao;
   private ComponentArtifactDao componentArtifactDao;
   private ProcessDao processDao;
@@ -80,8 +79,7 @@ public class OrchestrationUtil {
   private CompositionDataExtractor compositionDataExtractor;
 
   public OrchestrationUtil() {
-    this (VendorSoftwareProductDaoFactory.getInstance().createInterface(),
-          NicDaoFactory.getInstance().createInterface(),
+    this(NicDaoFactory.getInstance().createInterface(),
         MonitoringUploadDaoFactory.getInstance().createInterface(),
         ProcessDaoFactory.getInstance().createInterface(),
         OrchestrationTemplateDaoFactory.getInstance().createInterface(),
@@ -93,7 +91,6 @@ public class OrchestrationUtil {
   }
 
   public OrchestrationUtil(
-      VendorSoftwareProductDao vendorSoftwareProductDao,
       NicDao nicDao,
       ComponentArtifactDao componentArtifactDao,
       ProcessDao processDao,
@@ -103,7 +100,6 @@ public class OrchestrationUtil {
       ComponentDependencyModelDao componentDependencyModelDao,
       CompositionEntityDataManager compositionEntityDataManager,
       CompositionDataExtractor compositionDataExtractor) {
-    this.vendorSoftwareProductDao = vendorSoftwareProductDao;
     this.nicDao = nicDao;
     this.componentArtifactDao = componentArtifactDao;
     this.processDao = processDao;
@@ -116,8 +112,7 @@ public class OrchestrationUtil {
   }
 
   public static Optional<FileContentHandler> getFileContentMap(OnboardingTypesEnum type,
-                                                               UploadFileResponse
-                                                                   uploadFileResponse,
+                                                               UploadFileResponse uploadFileResponse,
                                                                byte[] uploadedFileData) {
     FileContentHandler contentMap = null;
     try {
@@ -133,95 +128,63 @@ public class OrchestrationUtil {
     return Optional.ofNullable(contentMap);
   }
 
-  public void backupComponentsQuestionnaireBeforeDelete(String vspId, Version activeVersion,
-                                           Map<String, String> componentsQustanniare,
-                                           Map<String, Map<String, String>>
-                                               componentNicsQustanniare,
-                                           Map<String, Collection<ComponentMonitoringUploadEntity>>
-                                               componentMibList,
-                                           Map<String, Collection<ProcessEntity>>
-                                               componentProcesses,
-                                           Map<String, ProcessEntity> processArtifact) {
-    //backup VSP processes
-    backupProcess(vspId, activeVersion, GENERAL_COMPONENT_ID, GENERAL_COMPONENT_ID,
-        componentProcesses, processArtifact);
-    Collection<ComponentEntity> componentsCompositionAndQuestionnaire = vendorSoftwareProductDao
-        .listComponentsCompositionAndQuestionnaire(vspId,
-            activeVersion);
+  public void backupComponentsQuestionnaireBeforeDelete(String vspId, Version version,
+                                                        Map<String, String> componentsQustanniare,
+                                                        Map<String, Map<String, String>>
+                                                            componentNicsQustanniare,
+                                                        Map<String, Collection<ComponentMonitoringUploadEntity>>
+                                                            componentMibList,
+                                                        Map<String, Collection<ProcessEntity>>
+                                                            componentProcesses,
+                                                        Map<String, ProcessEntity> processArtifact) {
+
+    Collection<ComponentEntity> componentsCompositionAndQuestionnaire =
+        componentDao.listCompositionAndQuestionnaire(vspId, version);
     componentsCompositionAndQuestionnaire.forEach(componentEntity ->
-        backupComponentQuestionnaire(vspId, activeVersion, componentEntity, componentsQustanniare,
+        backupComponentQuestionnaire(vspId, version, componentEntity, componentsQustanniare,
             componentNicsQustanniare, componentMibList, componentProcesses, processArtifact));
   }
 
-  private void backupComponentQuestionnaire(String vspId, Version activeVersion,
-                                            ComponentEntity componentEntity,
-                                            Map<String, String> componentsQustanniare,
-                                            Map<String, Map<String, String>>
-                                                componentNicsQustanniare,
-                                            Map<String, Collection<ComponentMonitoringUploadEntity>>
-                                                componentMibList,
-                                            Map<String, Collection<ProcessEntity>>
-                                                componentProcesses,
-                                            Map<String, ProcessEntity> processArtifact) {
+  private void backupComponentQuestionnaire(
+      String vspId, Version version,
+      ComponentEntity componentEntity,
+      Map<String, String> componentsQustanniare,
+      Map<String, Map<String, String>> componentNicsQustanniare,
+      Map<String, Collection<ComponentMonitoringUploadEntity>> componentMibList,
+      Map<String, Collection<ProcessEntity>> componentProcesses,
+      Map<String, ProcessEntity> processArtifact) {
     String componentName = componentEntity.getComponentCompositionData().getName();
-    backupMibData(componentsQustanniare, componentMibList, componentName, componentEntity, vspId,
-        activeVersion);
-    backupComponentProcessData(componentNicsQustanniare, vspId, activeVersion, componentName,
-        componentEntity, componentProcesses, processArtifact);
+    componentsQustanniare.put(componentName, componentEntity.getQuestionnaireData());
+    backupMibData(vspId, version, componentEntity, componentName, componentMibList);
+    backupProcess(vspId, version, componentEntity.getId(), componentName, componentProcesses,
+        processArtifact);
+    backupNicsQuestionnaire(vspId, version, componentEntity, componentName,
+        componentNicsQustanniare);
   }
 
-  private void backupMibData(Map<String, String> componentsQustanniare,
-                             Map<String, Collection<ComponentMonitoringUploadEntity>>
-                                 componentMibList,
-                             String componentName, ComponentEntity componentEntity,
-                             String vspId, Version activeVersion) {
-    componentsQustanniare.put(componentName, componentEntity.getQuestionnaireData());
-    //backup mib
+  private void backupMibData(String vspId, Version version, ComponentEntity componentEntity,
+                             String componentName,
+                             Map<String, Collection<ComponentMonitoringUploadEntity>> componentMibList) {
     Collection<ComponentMonitoringUploadEntity> componentMib =
         componentArtifactDao.listArtifacts(new
-            ComponentMonitoringUploadEntity(vspId, activeVersion, componentEntity.getId(), null));
+            ComponentMonitoringUploadEntity(vspId, version, componentEntity.getId(),
+            null));
     if (CollectionUtils.isNotEmpty(componentMib)) {
       componentMibList.put(componentName, componentMib);
     }
   }
 
-  private void backupComponentProcessData(Map<String, Map<String, String>> componentNicsQustanniare,
-                                          String vspId, Version activeVersion, String componentName,
-                                          ComponentEntity componentEntity,
-                                          Map<String, Collection<ProcessEntity>> componentProcesses,
-                                          Map<String, ProcessEntity> processArtifact) {
-    Collection<NicEntity>
-        nics = nicDao.list(new NicEntity(vspId, activeVersion, componentEntity.getId(), null));
-    //backup component processes
-    backupProcess(vspId, activeVersion, componentEntity.getId(), componentName,
-        componentProcesses, processArtifact);
-    if (CollectionUtils.isNotEmpty(nics)) {
-      Map<String, String> nicsQustanniare = new HashMap<>();
-      nics.forEach(nicEntity -> {
-        NicEntity nic = nicDao.get(new NicEntity(vspId, activeVersion, componentEntity.getId(),
-            nicEntity.getId()));
-        NicEntity nicQuestionnaire = nicDao.getQuestionnaireData(vspId, activeVersion,
-            componentEntity.getId(), nicEntity.getId());
-
-        nicsQustanniare
-            .put(nicEntity.getNicCompositionData().getName(),
-                nicQuestionnaire.getQuestionnaireData());
-      });
-      componentNicsQustanniare.put(componentName, nicsQustanniare);
-    }
-  }
-
-  private void backupProcess(String vspId, Version activeVersion, String componentId,
-                                    String componentName, Map<String,
+  private void backupProcess(String vspId, Version version, String componentId,
+                             String componentName, Map<String,
       Collection<ProcessEntity>> processes,
-                                    Map<String, ProcessEntity> processArtifact) {
-    Collection<ProcessEntity> processList = vendorSoftwareProductDao.listProcesses(vspId,
-        activeVersion, componentId);
+                             Map<String, ProcessEntity> processArtifact) {
+    Collection<ProcessEntity> processList =
+        processDao.list(new ProcessEntity(vspId, version, componentId, null));
     if (!processList.isEmpty()) {
       processes.put(componentName, processList);
       processList.forEach(process -> {
-        ProcessEntity artifact =
-            processDao.get(new ProcessEntity(vspId, activeVersion, componentId, process.getId()));
+        ProcessEntity artifact = processDao
+            .getArtifact(new ProcessEntity(vspId, version, componentId, process.getId()));
         if (artifact.getArtifact() != null) {
           processArtifact.put(process.getId(), artifact);
         }
@@ -229,29 +192,45 @@ public class OrchestrationUtil {
     }
   }
 
-  public void retainComponentQuestionnaireData(String vspId, Version activeVersion,
-                          Map<String, String> componentsQustanniare,
-                          Map<String, Map<String, String>>
-                              componentNicsQustanniare,
-                          Map<String, Collection<ComponentMonitoringUploadEntity>> componentMibList,
-                          Map<String, Collection<ProcessEntity>> processes,
-                          Map<String, ProcessEntity> processArtifact) {
+  private void backupNicsQuestionnaire(String vspId, Version version,
+                                       ComponentEntity componentEntity,
+                                       String componentName,
+                                       Map<String, Map<String, String>> componentNicsQustanniare) {
+    Collection<NicEntity>
+        nics = nicDao.list(new NicEntity(vspId, version, componentEntity.getId(), null));
+    if (CollectionUtils.isNotEmpty(nics)) {
+      Map<String, String> nicsQuestionnaire = new HashMap<>();
+      nics.forEach(nicEntity -> {
+        NicEntity nicQuestionnaire = nicDao.getQuestionnaireData(vspId, version,
+            componentEntity.getId(), nicEntity.getId());
+
+        nicsQuestionnaire.put(nicEntity.getNicCompositionData().getName(),
+            nicQuestionnaire.getQuestionnaireData());
+      });
+      componentNicsQustanniare.put(componentName, nicsQuestionnaire);
+    }
+  }
+
+  public void retainComponentQuestionnaireData(String vspId, Version version,
+                                               Map<String, String> componentsQustanniare,
+                                               Map<String, Map<String, String>>
+                                                   componentNicsQustanniare,
+                                               Map<String, Collection<ComponentMonitoringUploadEntity>> componentMibList,
+                                               Map<String, Collection<ProcessEntity>> processes,
+                                               Map<String, ProcessEntity> processArtifact) {
     //VSP processes
-    restoreProcess(vspId, activeVersion, GENERAL_COMPONENT_ID, GENERAL_COMPONENT_ID, processes,
-        processArtifact);
-    Collection<ComponentEntity>
-        components = vendorSoftwareProductDao.listComponents(vspId, activeVersion);
+    restoreProcess(vspId, version, null, null, processes, processArtifact);
+    Collection<ComponentEntity> components =
+        componentDao.list(new ComponentEntity(vspId, version, null));
     components.forEach(componentEntity -> {
       String componentName = componentEntity.getComponentCompositionData().getName();
       if (componentsQustanniare.containsKey(componentName)) {
-        //Restore component questionnaire
-        componentDao.updateQuestionnaireData(vspId, activeVersion,
+        componentDao.updateQuestionnaireData(vspId, version,
             componentEntity.getId(),
             componentsQustanniare.get(componentEntity.getComponentCompositionData()
                 .getName()));
-        //Restore component nic questionnaire
         if (componentNicsQustanniare.containsKey(componentName)) {
-          restoreComponentNicQuestionnaire(vspId, activeVersion, componentName, componentEntity,
+          restoreComponentNicQuestionnaire(vspId, version, componentName, componentEntity,
               componentNicsQustanniare);
         }
         //MIB //todo add for VES_EVENTS
@@ -259,33 +238,30 @@ public class OrchestrationUtil {
           restoreComponentMibData(componentName, componentEntity, componentMibList);
         }
         //VFC processes
-        restoreProcess(vspId, activeVersion, componentEntity.getId(), componentName, processes,
+        restoreProcess(vspId, version, componentEntity.getId(), componentName, processes,
             processArtifact);
       }
     });
   }
 
-  private void restoreComponentNicQuestionnaire(String vspId, Version activeVersion,
+  private void restoreComponentNicQuestionnaire(String vspId, Version version,
                                                 String componentName,
                                                 ComponentEntity componentEntity,
-                                                Map<String, Map<String, String>>
-                                                    componentNicsQustanniare) {
+                                                Map<String, Map<String, String>> componentNicsQustanniare) {
     Map<String, String> nicsQustanniare = componentNicsQustanniare.get(componentName);
     Collection<NicEntity> nics =
-        nicDao.list(new NicEntity(vspId, activeVersion, componentEntity.getId(), null));
+        nicDao.list(new NicEntity(vspId, version, componentEntity.getId(), null));
     nics.forEach(nicEntity -> {
       if (nicsQustanniare.containsKey(nicEntity.getNicCompositionData().getName())) {
-        nicDao.updateQuestionnaireData(vspId, activeVersion,
+        nicDao.updateQuestionnaireData(vspId, version,
             componentEntity.getId(), nicEntity.getId(),
             nicsQustanniare.get(nicEntity.getNicCompositionData().getName()));
       }
     });
   }
 
-  private void restoreComponentMibData(String componentName,
-                                       ComponentEntity componentEntity,
-                                       Map<String, Collection<ComponentMonitoringUploadEntity>>
-                                           componentMibList) {
+  private void restoreComponentMibData(String componentName, ComponentEntity componentEntity,
+                                       Map<String, Collection<ComponentMonitoringUploadEntity>> componentMibList) {
     Collection<ComponentMonitoringUploadEntity> mibList = componentMibList.get(componentName);
     mibList.forEach(mib -> {
       mib.setComponentId(componentEntity.getId());
@@ -293,54 +269,58 @@ public class OrchestrationUtil {
     });
   }
 
-  private void restoreProcess(String vspId, Version activeVersion, String componentId,
-                                     String componentName,
-                                     Map<String, Collection<ProcessEntity>> processes,
-                                     Map<String, ProcessEntity> processArtifact) {
+  private void restoreProcess(String vspId, Version version, String componentId,
+                              String componentName,
+                              Map<String, Collection<ProcessEntity>> processes,
+                              Map<String, ProcessEntity> processArtifact) {
     if (processes.containsKey(componentName)) {
       Collection<ProcessEntity> processList = processes.get(componentName);
       processList.forEach(process -> {
-        //Reatin VFC process
-        if (!GENERAL_COMPONENT_ID.equals(componentId)
-            && processArtifact.containsKey(process.getId())) {
+        process.setComponentId(componentId);
+        UniqueValueUtil.createUniqueValue(PROCESS_NAME, vspId, version.getId(), componentId,
+            process.getName());
+        processDao.create(process);
+        if (processArtifact.containsKey(process.getId())) {
           ProcessEntity artifact = processArtifact.get(process.getId());
-          artifact.setComponentId(componentId);
-          UniqueValueUtil.createUniqueValue(PROCESS_NAME, vspId, activeVersion.toString(),
-              componentId, process.getName());
-          vendorSoftwareProductDao.createProcess(artifact);
+          processDao.uploadArtifact(artifact);
         }
       });
     }
   }
 
   public void deleteUploadDataAndContent(String vspId, Version version) {
-    //fixme change this when more tables are zusammenized
-    vendorSoftwareProductDao.deleteUploadData(vspId, version);
+    VendorSoftwareProductInfoDaoFactory.getInstance().createInterface()
+        .delete(new VspDetails(vspId, version));
   }
 
-  public void saveUploadData(String vspId, Version activeVersion,
-                                    InputStream uploadedFileData,
-                                    FileContentHandler fileContentMap, HeatStructureTree tree) {
+  public void saveUploadData(VspDetails vspDetails,
+                             OrchestrationTemplateCandidateData candidateData,
+                             InputStream uploadedFileData,
+                             FileContentHandler fileContentMap, HeatStructureTree tree) {
     Map<String, Object> manifestAsMap =
         fileContentMap.containsFile(SdcCommon.MANIFEST_NAME)
             ? (Map<String, Object>) JsonUtil.json2Object(fileContentMap.getFileContent(
             SdcCommon.MANIFEST_NAME), Map.class)
             : new HashMap<>();
 
-    UploadData uploadData = new UploadData();
+    OrchestrationTemplateEntity uploadData = new OrchestrationTemplateEntity();
+    uploadData.setFileSuffix(candidateData.getFileSuffix());
+    uploadData.setFileName(candidateData.getFileName());
     uploadData.setContentData(ByteBuffer.wrap(FileUtils.toByteArray(uploadedFileData)));
     uploadData.setValidationDataStructure(new ValidationStructureList(tree));
     uploadData.setPackageName(Objects.isNull(manifestAsMap.get("name")) ? null :
         (String) manifestAsMap.get("name"));
     uploadData.setPackageVersion(Objects.isNull(manifestAsMap.get("version")) ? null :
         (String) manifestAsMap.get("version"));
-    orchestrationTemplateDataDao.updateOrchestrationTemplateData(vspId, uploadData);
+    orchestrationTemplateDataDao.update(vspDetails.getId(), vspDetails.getVersion(), uploadData);
+
+    VspMergeDaoFactory.getInstance().createInterface()
+        .updateVspModelId(vspDetails.getId(), vspDetails.getVersion());
   }
 
-  public void saveServiceModel(String vspId,
-                                      Version version,
-                                      ToscaServiceModel serviceModelToExtract,
-                                      ToscaServiceModel serviceModelToStore) {
+  public void saveServiceModel(String vspId, Version version,
+                               ToscaServiceModel serviceModelToExtract,
+                               ToscaServiceModel serviceModelToStore) {
     if (serviceModelToExtract != null) {
       serviceModelDao.storeServiceModel(vspId, version, serviceModelToStore);
       //Extracting the compostion data from the output service model of the first phase of
@@ -358,15 +338,14 @@ public class OrchestrationUtil {
     return heatTreeManager.getTree();
   }
 
-  public void updateVspComponentDependencies(String vspId, Version activeVersion,
-                                                    Map<String, String>
-                                                        vspComponentIdNameInfoBeforeProcess) {
-    Map<String, String> updatedVspComponentNameIdInfo = getVspComponentNameIdInfo(vspId,
-        activeVersion);
+  public void updateVspComponentDependencies(String vspId, Version version,
+                                             Map<String, String> vspComponentIdNameInfoBeforeProcess) {
+    Map<String, String> updatedVspComponentNameIdInfo = getVspComponentNameIdInfo(vspId, version);
     if (MapUtils.isNotEmpty(updatedVspComponentNameIdInfo)) {
       Set<String> updatedVspComponentNames = updatedVspComponentNameIdInfo.keySet();
       Collection<ComponentDependencyModelEntity> componentDependencies =
-          vendorSoftwareProductDao.listComponentDependencies(vspId, activeVersion);
+          componentDependencyModelDao.list(new ComponentDependencyModelEntity(vspId,
+              version, null));
       if (CollectionUtils.isNotEmpty(componentDependencies)) {
         updateComponentDependency(vspComponentIdNameInfoBeforeProcess, componentDependencies,
             updatedVspComponentNames, updatedVspComponentNameIdInfo);
@@ -374,7 +353,6 @@ public class OrchestrationUtil {
     }
   }
 
-
   private void updateComponentDependency(Map<String, String> vspComponentIdNameInfoBeforeProcess,
                                          Collection<ComponentDependencyModelEntity>
                                              componentDependencies,
@@ -398,14 +376,14 @@ public class OrchestrationUtil {
     }
   }
 
-  public Map<String, String> getVspComponentIdNameInfo(String vspId, Version activeVersion) {
+  public Map<String, String> getVspComponentIdNameInfo(String vspId, Version version) {
     Collection<ComponentEntity> updatedVspComponents =
-        vendorSoftwareProductDao.listComponents(vspId, activeVersion);
+        componentDao.list(new ComponentEntity(vspId, version, null));
     Map<String, String> vspComponentIdNameMap = new HashMap<>();
     if (CollectionUtils.isNotEmpty(updatedVspComponents)) {
       vspComponentIdNameMap = updatedVspComponents.stream()
           .filter(componentEntity -> componentEntity.getComponentCompositionData() != null)
-          .collect(Collectors.toMap(componentEntity -> componentEntity.getId(),
+          .collect(Collectors.toMap(ComponentEntity::getId,
               componentEntity -> componentEntity.getComponentCompositionData().getName()));
 
     }
@@ -413,15 +391,16 @@ public class OrchestrationUtil {
   }
 
   private Map<String, String> getVspComponentNameIdInfo(String vspId,
-                                                              Version activeVersion) {
+                                                        Version version) {
     Collection<ComponentEntity> updatedVspComponents =
-        vendorSoftwareProductDao.listComponents(vspId, activeVersion);
+        componentDao.list(new ComponentEntity(vspId, version, null));
     Map<String, String> vspComponentNameIdMap = new HashMap<>();
     if (CollectionUtils.isNotEmpty(updatedVspComponents)) {
       vspComponentNameIdMap = updatedVspComponents.stream()
           .filter(componentEntity -> componentEntity.getComponentCompositionData() != null)
-          .collect(Collectors.toMap(componentEntity -> componentEntity
-            .getComponentCompositionData().getName(), componentEntity -> componentEntity.getId()));
+          .collect(Collectors
+              .toMap(componentEntity -> componentEntity.getComponentCompositionData().getName(),
+                  ComponentEntity::getId));
     }
     return vspComponentNameIdMap;
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/CSARConstants.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/CSARConstants.java
index 0d204ef2c0..cf04aadcfc 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/CSARConstants.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/CSARConstants.java
@@ -1,6 +1,7 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar;
 
 import com.google.common.collect.ImmutableSet;
+
 import static com.google.common.collect.ImmutableSet.of;
 public class CSARConstants {
 
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/OnboardingManifest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/OnboardingManifest.java
index d88d883e67..c0da130a9f 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/OnboardingManifest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/OnboardingManifest.java
@@ -7,12 +7,22 @@ import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.logging.api.Logger;
 import org.openecomp.sdc.logging.api.LoggerFactory;
 
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
 import java.nio.charset.StandardCharsets;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 import static org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder.getErrorWithParameters;
-import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.CSARConstants.*;
+import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.CSARConstants.METADATA_MF_ATTRIBUTE;
+import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.CSARConstants.SEPERATOR_MF_ATTRIBUTE;
+import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.CSARConstants.SOURCE_MF_ATTRIBUTE;
 
 public class OnboardingManifest {
     private static final Logger logger = LoggerFactory.getLogger(OnboardingManifest.class);
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationProcessFactory.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationProcessFactory.java
index 516d85c2a7..6200b287a1 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationProcessFactory.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationProcessFactory.java
@@ -27,13 +27,13 @@ public class OrchestrationProcessFactory {
 
   }
 
-  public static Optional<OrchestrationTemplateProcessHandler> getInstance(String filePrefix) {
-    if (filePrefix == null) {
+  public static Optional<OrchestrationTemplateProcessHandler> getInstance(String fileSuffix) {
+    if (fileSuffix == null) {
       return Optional.empty();
     }
 
-    filePrefix = filePrefix.toLowerCase().trim();
-    OnboardingTypesEnum onboardingTypesEnum = OnboardingTypesEnum.getOnboardingTypesEnum(filePrefix);
+    fileSuffix = fileSuffix.toLowerCase().trim();
+    OnboardingTypesEnum onboardingTypesEnum = OnboardingTypesEnum.getOnboardingTypesEnum(fileSuffix);
     if (onboardingTypesEnum == null) {
       return Optional.empty();
     }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessCsarHandler.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessCsarHandler.java
index d217c31f65..b0e1e17f57 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessCsarHandler.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessCsarHandler.java
@@ -1,7 +1,6 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.process;
 
 import org.apache.commons.collections4.MapUtils;
-import org.openecomp.core.converter.ToscaConverter;
 import org.openecomp.core.impl.ToscaConverterImpl;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
@@ -26,7 +25,6 @@ import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.OrchestrationU
 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
 import org.openecomp.sdc.vendorsoftwareproduct.types.OrchestrationTemplateActionResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
-import org.openecomp.sdc.versioning.dao.types.Version;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -37,35 +35,35 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
-public class OrchestrationTemplateProcessCsarHandler implements OrchestrationTemplateProcessHandler {
-
-  private static final Logger logger = LoggerFactory.getLogger(OrchestrationTemplateProcessCsarHandler.class);
-  private CandidateService candidateService = CandidateServiceFactory.getInstance().createInterface();
+public class OrchestrationTemplateProcessCsarHandler
+    implements OrchestrationTemplateProcessHandler {
+  private static final Logger LOGGER =
+      LoggerFactory.getLogger(OrchestrationTemplateProcessCsarHandler.class);
+  private CandidateService candidateService =
+      CandidateServiceFactory.getInstance().createInterface();
   ToscaTreeManager toscaTreeManager = new ToscaTreeManager();
 
   @Override
   public OrchestrationTemplateActionResponse process(VspDetails vspDetails,
-                                                     OrchestrationTemplateCandidateData candidateData,
-                                                     String user) {
-    String vspId = vspDetails.getId();
-    Version version = vspDetails.getVersion();
-    logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.CSAR_VALIDATION_STARTED + vspId);
-    OrchestrationTemplateActionResponse response = new OrchestrationTemplateActionResponse();
+                                                     OrchestrationTemplateCandidateData candidateData) {
+    LOGGER.audit(
+        AuditMessages.AUDIT_MSG + AuditMessages.CSAR_VALIDATION_STARTED + vspDetails.getId());
+
     UploadFileResponse uploadFileResponse = new UploadFileResponse();
-    Optional<FileContentHandler> fileContent =
-        OrchestrationUtil
-            .getFileContentMap(
-                OnboardingTypesEnum.CSAR, uploadFileResponse, candidateData.getContentData().array());
+    Optional<FileContentHandler> fileContent = OrchestrationUtil
+        .getFileContentMap(OnboardingTypesEnum.CSAR, uploadFileResponse,
+            candidateData.getContentData().array());
 
-    if(fileContent.isPresent()){
+    OrchestrationTemplateActionResponse response = new OrchestrationTemplateActionResponse();
+    if (fileContent.isPresent()) {
       try {
         FileContentHandler fileContentHandler = fileContent.get();
-        processCsar(vspId, version, fileContentHandler, candidateData, response);
-      } catch (CoreException e){
-        logger.error(e.getMessage());
+        processCsar(vspDetails, fileContentHandler, candidateData, response);
+      } catch (CoreException e) {
+        LOGGER.error(e.getMessage());
         response.addErrorMessageToMap(e.code().id(), e.code().message(),ErrorLevel.ERROR);
       } catch (IOException ioe) {
-        logger.error(ioe.getMessage());
+        LOGGER.error(ioe.getMessage());
         ErrorCode errorCode = new GeneralErrorBuilder(ioe.getMessage()).build();
         response.addErrorMessageToMap(errorCode.id(), errorCode.message(),ErrorLevel.ERROR);
       }
@@ -77,13 +75,13 @@ public class OrchestrationTemplateProcessCsarHandler implements OrchestrationTem
     return response;
   }
 
-  private void processCsar(String vspId, Version version,
+  private void processCsar(VspDetails vspDetails,
                            FileContentHandler fileContentHandler,
                            OrchestrationTemplateCandidateData candidateData,
                            OrchestrationTemplateActionResponse response) throws IOException {
     response.setFileNames(new ArrayList<>(fileContentHandler.getFileList()));
-    Map<String, List<ErrorMessage>> errors = validateCsar(fileContentHandler, response);
-    if(!isValid(errors)){
+    Map<String, List<ErrorMessage>> errors = validateCsar(fileContentHandler);
+    if (!isValid(errors)) {
       return;
     }
 
@@ -95,32 +93,31 @@ public class OrchestrationTemplateProcessCsarHandler implements OrchestrationTem
     Map<String, Collection<ProcessEntity>> processes = new HashMap<>();
     Map<String, ProcessEntity> processArtifact = new HashMap<>();
     OrchestrationUtil orchestrationUtil = new OrchestrationUtil();
-    orchestrationUtil.backupComponentsQuestionnaireBeforeDelete(vspId,
-        version, componentsQuestionnaire,
+    orchestrationUtil.backupComponentsQuestionnaireBeforeDelete(vspDetails.getId(),
+        vspDetails.getVersion(), componentsQuestionnaire,
         componentNicsQuestionnaire, componentMibList, processes, processArtifact);
 
     Optional<ByteArrayInputStream> zipByteArrayInputStream = candidateService
-        .fetchZipFileByteArrayInputStream(vspId, candidateData, null, OnboardingTypesEnum.CSAR, errors);
+        .fetchZipFileByteArrayInputStream(vspDetails.getId(), candidateData, null,
+            OnboardingTypesEnum.CSAR, errors);
 
-    orchestrationUtil.deleteUploadDataAndContent(vspId, version);
-    orchestrationUtil.saveUploadData(
-        vspId, version, zipByteArrayInputStream.get(), fileContentHandler, tree);
+    orchestrationUtil.deleteUploadDataAndContent(vspDetails.getId(), vspDetails.getVersion());
+    orchestrationUtil.saveUploadData(vspDetails, candidateData, zipByteArrayInputStream.get(),
+            fileContentHandler, tree);
 
     ToscaServiceModel toscaServiceModel = new ToscaConverterImpl().convert(fileContentHandler);
-    orchestrationUtil.saveServiceModel(vspId, version, toscaServiceModel, toscaServiceModel);
+    orchestrationUtil.saveServiceModel(vspDetails.getId(), vspDetails.getVersion(), toscaServiceModel,
+        toscaServiceModel);
 
   }
 
-  private void addFiles(FileContentHandler fileContentHandler){
-    for(Map.Entry<String, byte[]> fileEntry : fileContentHandler.getFiles().entrySet()){
+  private void addFiles(FileContentHandler fileContentHandler) {
+    for (Map.Entry<String, byte[]> fileEntry : fileContentHandler.getFiles().entrySet()) {
       toscaTreeManager.addFile(fileEntry.getKey(), fileEntry.getValue());
     }
   }
 
-  private Map<String, List<ErrorMessage>> validateCsar(FileContentHandler fileContentHandler,
-                                         OrchestrationTemplateActionResponse response){
-
-
+  private Map<String, List<ErrorMessage>> validateCsar(FileContentHandler fileContentHandler) {
     Map<String, List<ErrorMessage>> errors = new HashMap<>();
     addFiles(fileContentHandler);
     toscaTreeManager.createTree();
@@ -129,7 +126,7 @@ public class OrchestrationTemplateProcessCsarHandler implements OrchestrationTem
     return errors;
   }
 
-  private boolean isValid(Map<String, List<ErrorMessage>> errors){
+  private boolean isValid(Map<String, List<ErrorMessage>> errors) {
     return MapUtils.isEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, errors));
   }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessHandler.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessHandler.java
index 8b513b4347..1db48a5cc7 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessHandler.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessHandler.java
@@ -6,7 +6,7 @@ import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.types.OrchestrationTemplateActionResponse;
 
 public interface OrchestrationTemplateProcessHandler {
+
   OrchestrationTemplateActionResponse process(VspDetails vspDetails,
-                                              OrchestrationTemplateCandidateData candidateData,
-                                              String user);
+                                              OrchestrationTemplateCandidateData candidateData);
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessZipHandler.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessZipHandler.java
index 85ac26223f..da5cb01c79 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessZipHandler.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/process/OrchestrationTemplateProcessZipHandler.java
@@ -1,19 +1,12 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.process;
 
-import static org.openecomp.sdc.logging.messages.AuditMessages.HEAT_VALIDATION_ERROR;
-
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.collections4.MapUtils;
-import org.openecomp.core.model.dao.ServiceModelDao;
-import org.openecomp.core.model.dao.ServiceModelDaoFactory;
 import org.openecomp.core.translator.datatypes.TranslatorOutput;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.core.utilities.json.JsonUtil;
 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
 import org.openecomp.core.validation.util.MessageContainerUtil;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
-import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
-import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.common.utils.SdcCommon;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
@@ -31,18 +24,13 @@ import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateCan
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.factory.CandidateServiceFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.factory.CompositionDataExtractorFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.factory.CompositionEntityDataManagerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.OrchestrationUtil;
-import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionDataExtractor;
-import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
 import org.openecomp.sdc.vendorsoftwareproduct.types.OrchestrationTemplateActionResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.FilesDataStructure;
 import org.openecomp.sdc.vendorsoftwareproduct.utils.VendorSoftwareProductUtils;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdcrests.activitylog.types.ActivityType;
 
 import java.io.ByteArrayInputStream;
 import java.util.Collection;
@@ -51,41 +39,29 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
+import static org.openecomp.sdc.logging.messages.AuditMessages.HEAT_VALIDATION_ERROR;
+
 public class OrchestrationTemplateProcessZipHandler implements OrchestrationTemplateProcessHandler {
-  Logger logger = LoggerFactory.getLogger(OrchestrationTemplateProcessZipHandler.class);
+  private Logger logger = LoggerFactory.getLogger(OrchestrationTemplateProcessZipHandler.class);
   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
   private CandidateService candidateService =
       CandidateServiceFactory.getInstance().createInterface();
-  private ServiceModelDao serviceModelDao = ServiceModelDaoFactory.getInstance().createInterface();
-  private CompositionEntityDataManager compositionEntityDataManager =
-      CompositionEntityDataManagerFactory.getInstance().createInterface();
-  private CompositionDataExtractor compositionDataExtractor =
-      CompositionDataExtractorFactory.getInstance().createInterface();
-  private ActivityLogManager activityLogManager =
-      ActivityLogManagerFactory.getInstance().createInterface();
-
-
-  public OrchestrationTemplateProcessZipHandler(){}
 
+  @Override
   public OrchestrationTemplateActionResponse process(VspDetails vspDetails,
-                                                     OrchestrationTemplateCandidateData
-                                                         candidateData,
-                                                     String user) {
+                                                     OrchestrationTemplateCandidateData candidateData) {
     String vspId = vspDetails.getId();
     Version version = vspDetails.getVersion();
-    logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.HEAT_VALIDATION_STARTED
-        + vspId);
+    logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.HEAT_VALIDATION_STARTED + vspId);
     OrchestrationTemplateActionResponse response = new OrchestrationTemplateActionResponse();
     UploadFileResponse uploadFileResponse = new UploadFileResponse();
-    Optional<FileContentHandler> fileContent =
-        OrchestrationUtil
-            .getFileContentMap(
-                OnboardingTypesEnum.ZIP, uploadFileResponse,
-                candidateData.getContentData().array());
+    Optional<FileContentHandler> fileContent = OrchestrationUtil
+        .getFileContentMap(OnboardingTypesEnum.ZIP, uploadFileResponse,
+            candidateData.getContentData().array());
     if (!fileContent.isPresent()) {
       response.addStructureErrors(uploadFileResponse.getErrors());
       mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-      response.getErrors().values().forEach(errorList -> printAuditForErrors(errorList,vspId,
+      response.getErrors().values().forEach(errorList -> printAuditForErrors(errorList, vspId,
           HEAT_VALIDATION_ERROR));
       return response;
     }
@@ -100,7 +76,7 @@ public class OrchestrationTemplateProcessZipHandler implements OrchestrationTemp
           Messages.FOUND_UNASSIGNED_FILES.getErrorMessage(), ErrorLevel.ERROR);
 
       mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
-      response.getErrors().values().forEach(errorList -> printAuditForErrors(errorList,vspId,
+      response.getErrors().values().forEach(errorList -> printAuditForErrors(errorList, vspId,
           HEAT_VALIDATION_ERROR));
       return response;
     }
@@ -113,8 +89,8 @@ public class OrchestrationTemplateProcessZipHandler implements OrchestrationTemp
         .fetchZipFileByteArrayInputStream(
             vspId, candidateData, manifest, OnboardingTypesEnum.ZIP, uploadErrors);
     if (!zipByteArrayInputStream.isPresent()) {
-      response.getErrors().values().forEach(errorList -> printAuditForErrors(errorList,vspId,
-          HEAT_VALIDATION_ERROR));
+      response.getErrors().values()
+          .forEach(errorList -> printAuditForErrors(errorList, vspId, HEAT_VALIDATION_ERROR));
       return response;
     }
 
@@ -129,18 +105,19 @@ public class OrchestrationTemplateProcessZipHandler implements OrchestrationTemp
     OrchestrationUtil orchestrationUtil = new OrchestrationUtil();
     Map<String, String> vspComponentIdNameInfoBeforeProcess =
         orchestrationUtil.getVspComponentIdNameInfo(vspId, version);
-    orchestrationUtil.backupComponentsQuestionnaireBeforeDelete(vspId,
-        version, componentsQuestionnaire,
-        componentNicsQuestionnaire, componentMibList, processes, processArtifact);
+    orchestrationUtil
+        .backupComponentsQuestionnaireBeforeDelete(vspId, version, componentsQuestionnaire,
+            componentNicsQuestionnaire, componentMibList, processes, processArtifact);
 
     orchestrationUtil.deleteUploadDataAndContent(vspId, version);
-    orchestrationUtil.saveUploadData(vspId, version, zipByteArrayInputStream.get(), fileContentMap,
-        tree);
+    orchestrationUtil
+        .saveUploadData(vspDetails, candidateData, zipByteArrayInputStream.get(), fileContentMap,
+            tree);
 
-    response.getErrors().values().forEach(errorList -> printAuditForErrors(errorList,vspId,
+    response.getErrors().values().forEach(errorList -> printAuditForErrors(errorList, vspId,
         HEAT_VALIDATION_ERROR));
-    if ( MapUtils.isEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR,
-        response.getErrors()))) {
+    if (MapUtils
+        .isEmpty(MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, response.getErrors()))) {
       logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.HEAT_VALIDATION_COMPLETED + vspId);
     }
 
@@ -150,20 +127,17 @@ public class OrchestrationTemplateProcessZipHandler implements OrchestrationTemp
         HeatToToscaUtil.loadAndTranslateTemplateData(fileContentMap);
 
     ToscaServiceModel toscaServiceModel = translatorOutput.getToscaServiceModel();
-    orchestrationUtil.saveServiceModel(vspId, version, translatorOutput
-        .getNonUnifiedToscaServiceModel(), toscaServiceModel);
+    orchestrationUtil
+        .saveServiceModel(vspId, version, translatorOutput.getNonUnifiedToscaServiceModel(),
+            toscaServiceModel);
     orchestrationUtil.retainComponentQuestionnaireData(vspId, version, componentsQuestionnaire,
         componentNicsQuestionnaire, componentMibList, processes, processArtifact);
     orchestrationUtil.updateVspComponentDependencies(vspId, version,
         vspComponentIdNameInfoBeforeProcess);
+
     logger.audit(AuditMessages.AUDIT_MSG + AuditMessages.HEAT_TRANSLATION_COMPLETED + vspId);
     uploadFileResponse.addStructureErrors(uploadErrors);
 
-    ActivityLogEntity activityLogEntity =
-        new ActivityLogEntity(vspId, String.valueOf(version.getMajor() + 1),
-            ActivityType.UPLOAD_HEAT.toString(), user, true, "", "");
-    activityLogManager.addActionLog(activityLogEntity, user);
-
     mdcDataDebugMessage.debugExitMessage("VSP id", vspId);
     return response;
   }
@@ -182,8 +156,8 @@ public class OrchestrationTemplateProcessZipHandler implements OrchestrationTemp
 
     errorList.forEach(errorMessage -> {
       if (errorMessage.getLevel().equals(ErrorLevel.ERROR)) {
-        logger.audit(AuditMessages.AUDIT_MSG + String.format(auditType, errorMessage.getMessage(),
-            vspId));
+        logger.audit(
+            AuditMessages.AUDIT_MSG + String.format(auditType, errorMessage.getMessage(), vspId));
       }
     });
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/types/FileDataStructureDto.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/types/FileDataStructureDto.java
deleted file mode 100644
index 8cb367367c..0000000000
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/types/FileDataStructureDto.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * 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.
- * ============LICENSE_END=========================================================
- */
-
-package org.openecomp.sdc.vendorsoftwareproduct.types;
-
-import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.Module;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * @author Avrahamg
- * @since November 07, 2016
- */
-public class FileDataStructureDto {
-    private List<Module> modules = new ArrayList<>();
-    private List<String> unassigned = new ArrayList<>();
-    private List<String> artifacts = new ArrayList<>();
-    private List<String> nested = new ArrayList<>();
-
-    public List<Module> getModules() {
-        return modules;
-    }
-
-    public void setModules(List<Module> modules) {
-        this.modules = modules;
-    }
-
-    public List<String> getUnassigned() {
-        return unassigned;
-    }
-
-    public void setUnassigned(List<String> unassigned) {
-        this.unassigned = unassigned;
-    }
-
-    public List<String> getArtifacts() {
-        return artifacts;
-    }
-
-    public void setArtifacts(List<String> artifacts) {
-        this.artifacts = artifacts;
-    }
-
-    public List<String> getNested() {
-        return nested;
-    }
-
-    public void setNested(List<String> nested) {
-        this.nested = nested;
-    }
-}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/types/GetFileDataStructureResponseDTO.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/types/GetFileDataStructureResponseDTO.java
deleted file mode 100644
index c30978266f..0000000000
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/main/java/org/openecomp/sdc/vendorsoftwareproduct/types/GetFileDataStructureResponseDTO.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * 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.
- * ============LICENSE_END=========================================================
- */
-
-package org.openecomp.sdc.vendorsoftwareproduct.types;
-
-import org.openecomp.sdc.vendorsoftwareproduct.types.candidateheat.Module;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * @author Avrahamg
- * @since November 07, 2016
- */
-public class GetFileDataStructureResponseDTO {
-    private List<Module> modules = new ArrayList<>();
-    private List<String> unassigned = new ArrayList<>();
-    private List<String> artifacts = new ArrayList<>();
-    private List<String> nested = new ArrayList<>();
-
-    public List<Module> getModules() {
-        return modules;
-    }
-
-    public void setModules(List<Module> modules) {
-        this.modules = modules;
-    }
-
-    public List<String> getUnassigned() {
-        return unassigned;
-    }
-
-    public void setUnassigned(List<String> unassigned) {
-        this.unassigned = unassigned;
-    }
-
-    public List<String> getArtifacts() {
-        return artifacts;
-    }
-
-    public void setArtifacts(List<String> artifacts) {
-        this.artifacts = artifacts;
-    }
-
-    public List<String> getNested() {
-        return nested;
-    }
-
-    public void setNested(List<String> nested) {
-        this.nested = nested;
-    }
-}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeTest.java
index ab7a70b6a7..3df06ba8eb 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ComputeTest.java
@@ -1,33 +1,5 @@
 package org.openecomp.sdc.vendorsoftwareproduct;
 
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.ADD_COMPUTE_NOT_ALLOWED_IN_HEAT_ONBOARDING;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.DUPLICATE_COMPUTE_NAME_NOT_ALLOWED;
-
-import org.openecomp.core.utilities.CommonMethods;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
-import org.openecomp.sdc.vendorsoftwareproduct.impl.VendorSoftwareProductManagerImpl;
-import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.ListComputeResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentData;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComputeData;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
-import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Test;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
 public class ComputeTest {
 
   /*private static final String USER1 = "componentsTestUser1";
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorTest.java
index 45ba4fb434..77c81111a5 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/DeploymentFlavorTest.java
@@ -1,33 +1,5 @@
 package org.openecomp.sdc.vendorsoftwareproduct;
 
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.CREATE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.DUPLICATE_DEPLOYMENT_FLAVOR_MODEL_NOT_ALLOWED;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.FEATURE_GROUP_NOT_EXIST_FOR_VSP;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.INVALID_COMPONENT_COMPUTE_ASSOCIATION;
-import static org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes.INVALID_COMPUTE_FLAVOR_ID;
-import static org.openecomp.sdc.versioning.errors.VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST;
-import static org.openecomp.sdc.versioning.errors.VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND;
-
-import org.openecomp.core.utilities.CommonMethods;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.impl.VendorSoftwareProductManagerImpl;
-
-import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
-import org.testng.annotations.Test;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
 public class DeploymentFlavorTest {
   /*private static final String USER1 = "deploymentTestUser1";
   private static final String USER2 = "deploymentTestUser2";
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ImagesTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ImagesTest.java
index 5dcb7f9b62..d78f4045b6 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ImagesTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/ImagesTest.java
@@ -21,50 +21,48 @@ import static org.mockito.Mockito.verify;
 
 public class ImagesTest {
 
-    private static String VSP_ID = "VSP_ID";
-    private static String COMP_ID = "COMP_ID";
-    private static String ID = "ID";
-    private static String USER = "USER";
-    public static final Version VERSION01 = new Version(0, 1);
+  private static String VSP_ID = "VSP_ID";
+  private static String COMP_ID = "COMP_ID";
+  private static String ID = "ID";
+  public static final Version VERSION01 = new Version("version_id");
 
-    @Mock
-    private VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao;
+  @Mock
+  private VendorSoftwareProductInfoDao vendorSoftwareProductInfoDao;
 
-    @Mock
-    private CompositionEntityDataManager compositionEntityDataManager;
+  @Mock
+  private CompositionEntityDataManager compositionEntityDataManager;
 
-    @InjectMocks
-    @Spy
-    private ImageManagerImpl imageManager;
+  @InjectMocks
+  @Spy
+  private ImageManagerImpl imageManager;
 
-    @BeforeMethod
-    public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
-    }
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
 
-    @Test
-    public void createImage()
-    {
-        ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION01, COMP_ID, ID);
-        doReturn(true).when(vendorSoftwareProductInfoDao).isManual(anyObject(), anyObject());
+  @Test
+  public void createImage() {
+    ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION01, COMP_ID, ID);
+    doReturn(true).when(vendorSoftwareProductInfoDao).isManual(anyObject(), anyObject());
 
-        imageManager.createImage(imageEntity, USER);
-        verify(compositionEntityDataManager).createImage(imageEntity);
-    }
+    imageManager.createImage(imageEntity);
+    verify(compositionEntityDataManager).createImage(imageEntity);
+  }
 
-    @Test
-    public void createImageHeat()
-    {
-        ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION01, COMP_ID, ID);
-        doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(), anyObject());
-
-        try {
-            imageManager.createImage(imageEntity, USER);
-            Assert.fail();
-        } catch (CoreException exception) {
-            Assert.assertEquals(exception.code().id(), VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
-        }
+  @Test
+  public void createImageHeat() {
+    ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION01, COMP_ID, ID);
+    doReturn(false).when(vendorSoftwareProductInfoDao).isManual(anyObject(), anyObject());
+
+    try {
+      imageManager.createImage(imageEntity);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(),
+          VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
     }
+  }
   /*private static final String USER1 = "imageTestUser1";
   private static final String USER2 = "imageTestUser2";
   private static final Version VERSION01 = new Version(0, 1);
@@ -93,40 +91,40 @@ public class ImagesTest {
         vsp1 = vendorSoftwareProductManager.createNewVsp(VSPCommon
         .createVspDetails(null, null, "VSP_" + CommonMethods.nextUuId(), "Test-vsp1", "vendorName",
             "vlm1Id", "icon", "category", "subCategory", "123", null,
-            VSPCommon.OnboardingMethod.Manual.name()), USER1
+            VSPCommon.OnboardingMethod.Manual.name())1
         );
     vsp1Id = vsp1.getId();
 
     VspDetails vsp2 = vendorSoftwareProductManager.createNewVsp(VSPCommon
         .createVspDetails(null, null, "VSP_" + CommonMethods.nextUuId(), "Test-vsp2", "vendorName",
             "vlm1Id", "icon", "category", "subCategory", "123", null, VSPCommon.OnboardingMethod.
-                Manual.name()), USER1);
+                Manual.name())1);
     vsp2Id = vsp2.getId();
 
     VspDetails vsp3 = vendorSoftwareProductManager.createNewVsp(VSPCommon
         .createVspDetails(null, null, "VSP_" + CommonMethods.nextUuId(), "Test-vsp3",
             "vendorName",
             "vlm1Id", "icon", "category", "subCategory", "123", null, VSPCommon
-                .OnboardingMethod.HEAT.name()), USER1);
+                .OnboardingMethod.HEAT.name())1);
     vsp3Id = vsp3.getId();
 
     ComponentEntity comp = new ComponentEntity();
     comp.setVspId(vsp2Id);
     comp.setCompositionData(comp1);
-    ComponentEntity createdComp = vendorSoftwareProductManager.createComponent(comp, USER1);
+    ComponentEntity createdComp = vendorSoftwareProductManager.createComponent(comp1);
     comp1Id = createdComp.getId();
   }
 
   @Test
   public void testListImagesNonExistingVspId_negative() {
-    testList_negative("non existing vsp id", null, image1Id, USER1,
+    testList_negative("non existing vsp id", null, image1Id1,
         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST,
         "Versionable entity VendorSoftwareProduct with id non existing vsp id does not exist." );
   }
 
   @Test
   public void testListImagesNonExistingVfcId_negative() {
-    testList_negative(vsp1Id, VERSION01, "444", USER1,
+    testList_negative(vsp1Id, VERSION01, "444"1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component with Id 444 does not exist for Vendor Software Product "
             + "with id "+vsp1Id+ " and version "+VERSION01);
@@ -137,20 +135,20 @@ public class ImagesTest {
     createImageEntity("media-vsrx-vmdisk-15.1X49-D40.6.aki", "aki");
     createImageEntity("riverbed-15.1X49-D40.6.vdi", "vdi");
     final Collection<ImageEntity> imageEntities =
-        vendorSoftwareProductManager.listImages(vsp2Id, VERSION01, comp1Id, USER1);
+        vendorSoftwareProductManager.listImages(vsp2Id, VERSION01, comp1Id1);
     System.out.println("size::"+imageEntities.size());
   }
 
   @Test
   public void testCreateNonExistingVspId_negative() {
-    testCreate_negative(new ImageEntity("non existing vsp id", null, null, null), USER1,
+    testCreate_negative(new ImageEntity("non existing vsp id", null, null, null)1,
         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST,
         "Versionable entity VendorSoftwareProduct with id non existing vsp id does not exist.");
   }
 
   @Test
   public void testCreateNonExistingVfcId_negative() {
-    testCreate_negative(new ImageEntity(vsp1Id, VERSION01, "222", null), USER1,
+    testCreate_negative(new ImageEntity(vsp1Id, VERSION01, "222", null)1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component with Id 222 does not exist for Vendor Software Product "
             + "with id "+vsp1Id + " and version "+VERSION01);
@@ -158,8 +156,8 @@ public class ImagesTest {
 
   @Test(dependsOnMethods = "testUpdateNonExistingImageId_negative")
   public void testCreateOnAvailableVsp_negative() {
-    vendorSoftwareProductManager.checkin(vsp1Id, USER1);
-    testCreate_negative(new ImageEntity(vsp1Id, null, null, null), USER1,
+    vendorSoftwareProductManager.checkin(vsp1Id1);
+    testCreate_negative(new ImageEntity(vsp1Id, null, null, null)1,
         VersioningErrorCodes.EDIT_ON_UNLOCKED_ENTITY,
         "Can not edit versionable entity VendorSoftwareProduct with id "+vsp1Id+ " since it is not"
             + " checked out.");
@@ -167,8 +165,8 @@ public class ImagesTest {
 
   @Test(dependsOnMethods = "testCreateOnAvailableVsp_negative")
   public void testCreateOnVspOtherUser_negative() {
-    vendorSoftwareProductManager.checkout(vsp1Id, USER1);
-    testCreate_negative(new ImageEntity(vsp1Id, null, null, null), USER2,
+    vendorSoftwareProductManager.checkout(vsp1Id1);
+    testCreate_negative(new ImageEntity(vsp1Id, null, null, null)2,
         VersioningErrorCodes.EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER,
         "Versionable entity VendorSoftwareProduct with id " +vsp1Id+
             " can not be edited since it is locked by other user "+ USER1+ ".");
@@ -180,11 +178,11 @@ public class ImagesTest {
     ComponentEntity comp = new ComponentEntity();
     comp.setVspId(vsp1Id);
     comp.setCompositionData(comp1);
-    ComponentEntity createdComp = vendorSoftwareProductManager.createComponent(comp, USER1);
+    ComponentEntity createdComp = vendorSoftwareProductManager.createComponent(comp1);
     String compId = createdComp.getId();
 
-    vendorSoftwareProductManager.checkin(vsp1Id, USER1);
-    vendorSoftwareProductManager.checkout(vsp1Id, USER1);
+    vendorSoftwareProductManager.checkin(vsp1Id1);
+    vendorSoftwareProductManager.checkout(vsp1Id1);
 
     for(int i = 1; i<=3; i++) {
       ImageEntity imageEntity = new ImageEntity();
@@ -197,17 +195,17 @@ public class ImagesTest {
       //image.setFormat("aki");
       //image.setMd5("233343DDDD");
       imageEntity.setImageCompositionData(image);
-      ImageEntity createdImage = vendorSoftwareProductManager.createImage(imageEntity, USER1);
+      ImageEntity createdImage = vendorSoftwareProductManager.createImage(imageEntity1);
     }
 
     Collection<ImageEntity> imageEntities =
-        vendorSoftwareProductManager.listImages(vsp1Id, null, compId, USER1);
+        vendorSoftwareProductManager.listImages(vsp1Id, null, compId1);
 
     Assert.assertEquals(imageEntities.size(), 3);
 
-    vendorSoftwareProductManager.undoCheckout(vsp1Id, USER1);
+    vendorSoftwareProductManager.undoCheckout(vsp1Id1);
 
-    imageEntities = vendorSoftwareProductManager.listImages(vsp1Id, null, compId, USER1);
+    imageEntities = vendorSoftwareProductManager.listImages(vsp1Id, null, compId1);
 
     Assert.assertEquals(imageEntities.size(), 0);
   }
@@ -217,7 +215,7 @@ public class ImagesTest {
     final ErrorCode addImageNotSupportedHeatOnboardMethodErrorBuilder =
         NotSupportedHeatOnboardMethodErrorBuilder
             .getAddImageNotSupportedHeatOnboardMethodErrorBuilder();
-    testCreate_negative(new ImageEntity(vsp3Id, null, null, null), USER1,
+    testCreate_negative(new ImageEntity(vsp3Id, null, null, null)1,
         addImageNotSupportedHeatOnboardMethodErrorBuilder.id(),
         addImageNotSupportedHeatOnboardMethodErrorBuilder.message()
         );
@@ -252,19 +250,19 @@ public class ImagesTest {
   @Test
   public void testGet() {
     ImageEntity createdImage = createImageEntity("read-riverbed-WX-IMG-9.2.0.qcow2", "qcow2");
-    testGet(vsp2Id, VERSION01, comp1Id, createdImage.getId(), USER1, createdImage);
+    testGet(vsp2Id, VERSION01, comp1Id, createdImage.getId()1, createdImage);
   }
 
   @Test
   public void testGetNonExistingVspId_negative() {
-    testGet_negative("non existing vsp id", null, null, image1Id, USER1,
+    testGet_negative("non existing vsp id", null, null, image1Id1,
         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST,
         "Versionable entity VendorSoftwareProduct with id non existing vsp id does not exist." );
   }
 
   @Test
   public void testGetNonExistingVfcId_negative() {
-    testGet_negative(vsp1Id, VERSION01, "111", null, USER1,
+    testGet_negative(vsp1Id, VERSION01, "111", null1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component with Id 111 does not exist for Vendor Software Product "
             + "with id "+vsp1Id + " and version "+VERSION01);
@@ -274,7 +272,7 @@ public class ImagesTest {
   public void testUpdateNonExistingVspId_negative() {
     ImageEntity imageEntity = new ImageEntity("non existing vsp id", null, null, image1Id);
 
-    testUpdate_negative(imageEntity, USER1,
+    testUpdate_negative(imageEntity1,
         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST,
         "Versionable entity VendorSoftwareProduct with id non existing vsp id does not exist." );
   }
@@ -283,7 +281,7 @@ public class ImagesTest {
   public void testUpdateNonExistingVfcId_negative() {
     ImageEntity imageEntity = new ImageEntity(vsp1Id, VERSION01, "111", null);
 
-    testUpdate_negative(imageEntity, USER1,
+    testUpdate_negative(imageEntity1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component with Id 111 does not exist for Vendor Software Product "
             + "with id "+vsp1Id + " and version "+VERSION01);
@@ -293,7 +291,7 @@ public class ImagesTest {
   public void testUpdateNonExistingImageId_negative() {
     ImageEntity imageEntity = new ImageEntity(vsp2Id, VERSION01, comp1Id, "222");
 
-    testUpdate_negative(imageEntity, USER1,
+    testUpdate_negative(imageEntity1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component Image with Id 222 does not exist for Vendor " +
             "Software Product with id "+vsp2Id+ " and version "+VERSION01 );
@@ -308,7 +306,7 @@ public class ImagesTest {
     //imageCompositionData.setVersion("10.0");
     imageCompositionData.setDescription("updated image");
 
-    vendorSoftwareProductManager.updateImage(imageEntity, USER1);
+    vendorSoftwareProductManager.updateImage(imageEntity1);
 
     testGet(vsp2Id, VERSION01, comp1Id, imageEntity.getId(),USER1, imageEntity );
     image2Id = imageEntity.getId();
@@ -318,7 +316,7 @@ public class ImagesTest {
   public void testUpdateNegative_UniqueName() {
     final CompositionEntityResponse<Image> image =
         vendorSoftwareProductManager.getImage(vsp2Id, VERSION01, comp1Id,
-            image2Id, USER1);
+            image2Id1);
     final Image data = image.getData();
 
     final Image imageCompositionData = data;
@@ -326,7 +324,7 @@ public class ImagesTest {
 
     ImageEntity entity = new ImageEntity(vsp2Id, VERSION01, comp1Id, image2Id );
     entity.setImageCompositionData(imageCompositionData);
-    testUpdate_negative(entity, USER1, ImageErrorBuilder.getDuplicateImageNameErrorBuilder(
+    testUpdate_negative(entity1, ImageErrorBuilder.getDuplicateImageNameErrorBuilder(
         "riverbed-WX-IMG-9.2.0.qcow2", comp1Id).id()
         ,ImageErrorBuilder.getDuplicateImageNameErrorBuilder("riverbed-WX-IMG-9.2.0.qcow2", comp1Id)
             .message() );
@@ -335,13 +333,13 @@ public class ImagesTest {
   @Test(dependsOnMethods = "testUpdateNegative_UniqueName")
   public void testDeleteImage() {
     CompositionEntityResponse<Image> image =
-        vendorSoftwareProductManager.getImage(vsp2Id, VERSION01, comp1Id, image2Id, USER1);
+        vendorSoftwareProductManager.getImage(vsp2Id, VERSION01, comp1Id, image2Id1);
 
     Assert.assertNotNull(image.getData());
 
-    vendorSoftwareProductManager.deleteImage(vsp2Id, comp1Id, image2Id, USER1);
+    vendorSoftwareProductManager.deleteImage(vsp2Id, comp1Id, image2Id1);
 
-    testGet_negative(vsp2Id, VERSION01, comp1Id, image2Id, USER1,
+    testGet_negative(vsp2Id, VERSION01, comp1Id, image2Id1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component Image with Id "+image2Id+ " does not exist for " +
             "Vendor Software Product with id "+vsp2Id+ " and version "+VERSION01 );
@@ -352,7 +350,7 @@ public class ImagesTest {
   public void testDeleteNonExistingVspId_negative() {
     ImageEntity imageEntity = new ImageEntity("non existing vsp id", null, null, image1Id);
 
-    testDelete_negative(imageEntity, USER1,
+    testDelete_negative(imageEntity1,
         VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST,
         "Versionable entity VendorSoftwareProduct with id non existing vsp id does not exist." );
   }
@@ -361,7 +359,7 @@ public class ImagesTest {
   public void testDeleteNonExistingVfcId_negative() {
     ImageEntity imageEntity = new ImageEntity(vsp1Id, VERSION01, "111", null);
 
-    testDelete_negative(imageEntity, USER1,
+    testDelete_negative(imageEntity1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component with Id 111 does not exist for Vendor Software Product "
             + "with id "+vsp1Id + " and version "+VERSION01);
@@ -371,7 +369,7 @@ public class ImagesTest {
   public void testDeleteNonExistingImageId_negative() {
     ImageEntity imageEntity = new ImageEntity(vsp2Id, VERSION01, comp1Id, "222");
 
-    testDelete_negative(imageEntity, USER1,
+    testDelete_negative(imageEntity1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND,
         "Vendor Software Product Component Image with Id 222 does not exist for Vendor " +
             "Software Product with id "+vsp2Id+ " and version "+VERSION01 );
@@ -386,7 +384,7 @@ public class ImagesTest {
 
     final QuestionnaireResponse imageQuestionnaire =
         vendorSoftwareProductManager.getImageQuestionnaire(vsp2Id, VERSION01, comp1Id,
-            imageEntity.getId(), USER1);
+            imageEntity.getId()1);
 
     String imageDetails = imageQuestionnaire.getData();
     Assert.assertEquals("vdi", JsonUtil.json2Object(imageDetails, ImageDetails.class).getFormat());
@@ -422,7 +420,7 @@ public class ImagesTest {
     // image.setMd5("233343DDDD");
     imageEntity.setImageCompositionData(image);
 
-    ImageEntity createdImage = vendorSoftwareProductManager.createImage(imageEntity, USER1);
+    ImageEntity createdImage = vendorSoftwareProductManager.createImage(imageEntity1);
     image1Id = createdImage.getId();
     return createdImage;
   }
@@ -430,7 +428,7 @@ public class ImagesTest {
   private void testGet(String vspId, Version version, String componentId, String imageId, String
       user, ImageEntity expected) {
     CompositionEntityResponse<Image>
-        response = vendorSoftwareProductManager.getImage(vspId, null, componentId, imageId, user);
+        response = vendorSoftwareProductManager.getImage(vspId, null, componentId, imageId);
     Assert.assertEquals(response.getId(), expected.getId());
     Assert.assertEquals(expected.getImageCompositionData().getFileName(), response.getData().
         getFileName());
@@ -442,7 +440,7 @@ public class ImagesTest {
   private void testCreate_negative(ImageEntity image, String user,
                                    String expectedErrorCode, String expectedErrorMsg) {
     try {
-      vendorSoftwareProductManager.createImage(image, user);
+      vendorSoftwareProductManager.createImage(image);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
@@ -454,7 +452,7 @@ public class ImagesTest {
                                 String user,
                                 String expectedErrorCode, String expectedErrorMsg) {
     try {
-      vendorSoftwareProductManager.getImage(vspId, version, componentId, imageId, user);
+      vendorSoftwareProductManager.getImage(vspId, version, componentId, imageId);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
@@ -465,7 +463,7 @@ public class ImagesTest {
   private void testList_negative(String vspId, Version version, String componentId, String user,
                                  String expectedErrorCode, String expectedErrorMsg) {
     try {
-      vendorSoftwareProductManager.listImages(vspId, version, componentId, user);
+      vendorSoftwareProductManager.listImages(vspId, version, componentId);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
@@ -478,7 +476,7 @@ public class ImagesTest {
                                 String expectedErrorCode, String expectedErrorMsg) {
     try {
 
-      vendorSoftwareProductManager.updateImage(imageEntity, user);
+      vendorSoftwareProductManager.updateImage(imageEntity);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
@@ -491,7 +489,7 @@ public class ImagesTest {
                                    String expectedErrorCode, String expectedErrorMsg) {
     try {
 
-      vendorSoftwareProductManager.updateImage(imageEntity, user);
+      vendorSoftwareProductManager.updateImage(imageEntity);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/QuestionnaireDataServiceTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/QuestionnaireDataServiceTest.java
index b544d13ec7..e8e0f2c92b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/QuestionnaireDataServiceTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/QuestionnaireDataServiceTest.java
@@ -30,12 +30,10 @@ import org.mockito.MockitoAnnotations;
 import org.openecomp.core.model.dao.ServiceModelDao;
 import org.openecomp.core.model.types.ServiceElement;
 import org.openecomp.core.validation.util.MessageContainerUtil;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
 import org.openecomp.sdc.healing.api.HealingManager;
 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.OrchestrationTemplateCandidateManagerImpl;
 import org.openecomp.sdc.vendorsoftwareproduct.informationArtifact.InformationArtifactData;
 import org.openecomp.sdc.vendorsoftwareproduct.questionnaire.QuestionnaireDataService;
@@ -54,16 +52,11 @@ import java.io.InputStream;
 import java.util.List;
 import java.util.Objects;
 
-import static org.mockito.Mockito.verify;
-import static org.mockito.Matchers.eq;
-
 public class QuestionnaireDataServiceTest {
   public static final Version VERSION = new Version(0, 1);
   private QuestionnaireDataService questionnaireDataService;// = new QuestionnaireDataServiceImpl();
 
   @Mock
-  private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
-  @Mock
   private CandidateService candidateServiceMock;
   @Mock
   private HealingManager healingManagerMock;
@@ -73,8 +66,6 @@ public class QuestionnaireDataServiceTest {
   private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDaoMock;
   @Mock
   private CompositionEntityDataManager compositionEntityDataManagerMock;
-  @Mock
-  private ActivityLogManager activityLogManagerMock;
 
   @Captor
   private ArgumentCaptor<ActivityLogEntity> activityLogEntityArg;
@@ -82,7 +73,7 @@ public class QuestionnaireDataServiceTest {
   @InjectMocks
   private OrchestrationTemplateCandidateManagerImpl candidateManager;
 
-  private final UploadFileTest uploadFileTest = new UploadFileTest();
+  private UploadFileTest uploadFileTest = new UploadFileTest();
 
   private static String vspId;
   private static Version vspActiveVersion;
@@ -110,31 +101,27 @@ public class QuestionnaireDataServiceTest {
 
   // TODO: 3/15/2017 fix and enable   //@Test
   public void testQuestionnaireDataAfterIllegalUpload() throws IOException {
-
     try (InputStream zipInputStream = uploadFileTest.getZipInputStream("/missingYml")) {
-      UploadFileResponse uploadFileResponse = candidateManager
-              .upload(vspId, VERSION, zipInputStream, USER1, "zip", "missingYml");
+      UploadFileResponse uploadFileResponse =
+              candidateManager.upload(vspId, VERSION, zipInputStream, "zip", "missingYml");
     }
-
     InformationArtifactData informationArtifactData = questionnaireDataService
         .generateQuestionnaireDataForInformationArtifact(vspId, vspActiveVersion);
 
   }
 
   private InformationArtifactData uploadFileAndValidateInformationArtifactData(String filePath,
-                                                                               int listSizeToCheck) throws IOException {
+                                                                               int listSizeToCheck)
+            throws IOException {
 
     try (InputStream zipInputStream = uploadFileTest.getZipInputStream(filePath)) {
-      UploadFileResponse uploadFileResponse = candidateManager
-              .upload(vspId, VERSION,
-                      zipInputStream, USER1, "zip", "file");
-
-      candidateManager.process(vspId, VERSION, USER1);
+      UploadFileResponse uploadFileResponse =
+              candidateManager.upload(vspId, VERSION, zipInputStream, "zip", "file");
+      candidateManager.process(vspId, VERSION);
 
       Assert.assertTrue(MapUtils.isEmpty(
               MessageContainerUtil.getMessageByLevel(ErrorLevel.ERROR, uploadFileResponse.getErrors())));
     }
-
     InformationArtifactData informationArtifactData = questionnaireDataService
         .generateQuestionnaireDataForInformationArtifact(vspId, vspActiveVersion);
     Assert.assertNotNull(informationArtifactData);
@@ -143,11 +130,6 @@ public class QuestionnaireDataServiceTest {
         informationArtifactData.getComponentQuestionnaires();
     Assert.assertEquals(componentQuestionnaireList.size(), listSizeToCheck);
 
-    verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(),eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION.getMajor()+1));
-    Assert.assertTrue(activityLogEntity.isSuccess());
-
     return informationArtifactData;
   }
 
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelTest.java
index c3f78b6cb0..a2cbaa7eb6 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentDependencyModelTest.java
@@ -6,136 +6,217 @@ import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.ComponentManager;
-import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.ComponentDependencyModelErrorBuilder;
 import org.openecomp.sdc.versioning.dao.types.Version;
 import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
+import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.when;
+
 public class ComponentDependencyModelTest {
 
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+  private static final String VSP_ID = "vsp_id";
+  private static final Version VERSION = new Version("version_id");
+  private static final String COMP_DEP_ID = "comp_dep_id";
+
+  private static final String COMP_ID_1 = "comp_id_1";
+  private static final String COMP_ID_2 = "comp_id_2";
+  private static final String COMP_ID_3 = "comp_id_3";
+  private static final String COMP_ID_4 = "comp_id_4";
 
   @Spy
   @InjectMocks
   private ComponentDependencyModelManagerImpl componentDependencyModelManager;
   @Mock
-  private VendorSoftwareProductManager vendorSoftwareProductManager;
-  @Mock
-  private VendorSoftwareProductDao vendorSoftwareProductDao;
-  @Mock
-  private ComponentDao componentDao;
-  @Mock
   private ComponentManager componentManager;
+  @Mock
+  private ComponentDependencyModelDao componentDependencyModelDao;
 
-  private static String vsp1Id;
-  private static String sourceComp1Id;
-  private static String sourceComp2Id;
-  private static String sourceComp3Id;
-  private static String sourceComp4Id;
-  private static final String USER1 = "TestUser1";
-  private static final String USER2 = "TestUser2";
-  private static final Version VERSION01 = new Version(0, 1);
-  private static String modelId = "model1";
-
-
-  @BeforeClass
+  @BeforeMethod
   private void init() {
     MockitoAnnotations.initMocks(this);
   }
 
-  public static VspDetails createVspDetails(String id, Version version, String name, String desc,
-                                            String vendorName, String vlm, String icon,
-                                            String category, String subCategory,
-                                            String licenseAgreement, List<String> featureGroups
-  ) {
-    VspDetails vspDetails = new VspDetails(id, version);
-    vspDetails.setName(name);
-    vspDetails.setDescription(desc);
-    vspDetails.setIcon(icon);
-    vspDetails.setCategory(category);
-    vspDetails.setSubCategory(subCategory);
-    vspDetails.setVendorName(vendorName);
-    vspDetails.setVendorId(vlm);
-    vspDetails.setVlmVersion(new Version(1, 0));
-    vspDetails.setLicenseAgreement(licenseAgreement);
-    vspDetails.setFeatureGroups(featureGroups);
-    return vspDetails;
+  @Test
+  public void testListDependency() {
+    List<ComponentDependencyModelEntity> entities = new ArrayList<>();
+    entities.add(createModelEntity(COMP_ID_1, COMP_ID_2));
+    entities.add(createModelEntity(COMP_ID_3, COMP_ID_4));
+
+    Mockito.when(componentDependencyModelDao
+        .list(new ComponentDependencyModelEntity(VSP_ID, VERSION, null)))
+        .thenReturn(entities);
+
+    Collection<ComponentDependencyModelEntity> list =
+        componentDependencyModelManager.list(VSP_ID, VERSION);
+
+    Mockito.verify(componentDependencyModelDao, Mockito.times(1))
+        .list(new ComponentDependencyModelEntity(VSP_ID, VERSION, null));
+
+    Assert.assertEquals(2, list.size());
+  }
+
+  @Test
+  public void testCreateDependency() {
+    ComponentDependencyModelEntity modelEntity =
+        createModelEntity(COMP_ID_1, COMP_ID_2);
+
+    componentDependencyModelManager.createComponentDependency(modelEntity, VSP_ID, VERSION);
+    Mockito.verify(componentDependencyModelDao, Mockito.times(1)).create(modelEntity);
+  }
+
+  @Test
+  public void testCreateDependencyNegative_SameSourceTarget() {
+    ComponentDependencyModelEntity modelEntity =
+        createModelEntity(COMP_ID_1, COMP_ID_1);
+    testCreateDependency_negative(modelEntity, VSP_ID, VERSION,
+        ComponentDependencyModelErrorBuilder.getSourceTargetComponentEqualErrorBuilder().id(),
+        ComponentDependencyModelErrorBuilder.getSourceTargetComponentEqualErrorBuilder().message());
   }
 
   @Test
-  public void testCreateNegative_NoSourceId() {
-    List<ComponentDependencyModelEntity> entities = new ArrayList<ComponentDependencyModelEntity>();
-    entities.add(createModelEntity(null, sourceComp2Id));
-    testCreate_negative(entities, vsp1Id, VERSION01, USER1,
+  public void testCreateDependencyNegative_NoSourceId() {
+
+    ComponentDependencyModelEntity modelEntity = createModelEntity(null, COMP_ID_1);
+    testCreateDependency_negative(modelEntity, VSP_ID, VERSION,
         ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().id(),
         ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().message());
 
-    entities.clear();
-    entities.add(createModelEntity("", sourceComp2Id));
-    testCreate_negative(entities, vsp1Id, VERSION01, USER1,
+
+    ComponentDependencyModelEntity modelEntity1 = createModelEntity("", COMP_ID_1);
+    testCreateDependency_negative(modelEntity1, VSP_ID, VERSION,
         ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().id(),
         ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().message());
   }
 
   @Test
-  public void testCreateNegative_SameSourceTarget() {
-    List<ComponentDependencyModelEntity> entities = new ArrayList<ComponentDependencyModelEntity>();
-    entities.add(createModelEntity("sourceComp1Id", "sourceComp1Id"));
-    testCreate_negative(entities, vsp1Id, VERSION01, USER1,
+  public void testUpdateDependency() {
+    ComponentDependencyModelEntity modelEntity =
+        createModelEntity(COMP_ID_1, COMP_ID_2);
+    modelEntity.setId(COMP_DEP_ID);
+
+    when(componentDependencyModelDao.get(anyObject())).thenReturn(modelEntity);
+
+    componentDependencyModelManager.update(modelEntity);
+    Mockito.verify(componentDependencyModelDao, Mockito.times(1)).update(modelEntity);
+  }
+
+  @Test
+  public void testUpdateDependencyNegative_NoSourceId() {
+
+    ComponentDependencyModelEntity modelEntity = createModelEntity(null, COMP_ID_1);
+    modelEntity.setId(COMP_DEP_ID);
+
+    when(componentDependencyModelDao.get(anyObject())).thenReturn(modelEntity);
+
+    testUpdateDependency_negative(modelEntity,
+        ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().id(),
+        ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().message());
+
+    ComponentDependencyModelEntity modelEntity1 = createModelEntity("", COMP_ID_1);
+    modelEntity1.setId(COMP_DEP_ID);
+
+    when(componentDependencyModelDao.get(anyObject())).thenReturn(modelEntity1);
+
+    testUpdateDependency_negative(modelEntity1,
+        ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().id(),
+        ComponentDependencyModelErrorBuilder.getNoSourceComponentErrorBuilder().message());
+  }
+
+  @Test
+  public void testUpdateDependencyNegative_SameSourceTarget() {
+    ComponentDependencyModelEntity modelEntity =
+        createModelEntity(COMP_ID_1, COMP_ID_1);
+    modelEntity.setId(COMP_DEP_ID);
+
+    when(componentDependencyModelDao.get(anyObject())).thenReturn(modelEntity);
+    testUpdateDependency_negative(modelEntity,
         ComponentDependencyModelErrorBuilder.getSourceTargetComponentEqualErrorBuilder().id(),
         ComponentDependencyModelErrorBuilder.getSourceTargetComponentEqualErrorBuilder().message());
   }
 
   @Test
-  public void testCreate() {
-    List<ComponentDependencyModelEntity> entities = new ArrayList<ComponentDependencyModelEntity>();
-    entities.add(createModelEntity("sourceComp1Id", "sourceComp2Id"));
-    entities.add(createModelEntity("sourceComp3Id", "sourceComp4Id"));
-
-    componentDependencyModelManager.createComponentDependencyModel(entities, vsp1Id, VERSION01,
-        USER1);
-    Mockito.verify(vendorSoftwareProductDao, Mockito.times(1)).createComponentDependencyModel
-        (entities, vsp1Id,
-        VERSION01);
+  public void testDeleteDependency() {
+    ComponentDependencyModelEntity modelEntity =
+        createModelEntity(COMP_ID_1, COMP_ID_2);
+    modelEntity.setId(COMP_DEP_ID);
+
+    when(componentDependencyModelDao.get(anyObject())).thenReturn(modelEntity);
+
+    componentDependencyModelManager.delete(VSP_ID, VERSION, COMP_DEP_ID);
+    Mockito.verify(componentDependencyModelDao, Mockito.times(1)).delete(modelEntity);
+  }
+
+  @Test
+  public void testDeleteInvalidDependency() {
+    ComponentDependencyModelEntity delModelEntity =
+        createModelEntity(COMP_ID_1, COMP_ID_2);
+    delModelEntity.setId(COMP_DEP_ID);
+
+    try {
+      componentDependencyModelManager.delete(VSP_ID, VERSION, COMP_DEP_ID);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), "VERSIONABLE_SUB_ENTITY_NOT_FOUND");
+      Assert.assertEquals(exception.getMessage(),
+          String.format("Vendor Software Product Component Dependency Model with Id %s " +
+                  "does not exist for Vendor Software Product with id %s and version %s",
+              COMP_DEP_ID, VSP_ID, VERSION.getId()));
+    }
+  }
+
+
+  @Test
+  public void testGetDependency() {
+    ComponentDependencyModelEntity modelEntity =
+        createModelEntity(COMP_ID_1, COMP_ID_2);
+    modelEntity.setId(COMP_DEP_ID);
+
+    when(componentDependencyModelDao.get(anyObject())).thenReturn(modelEntity);
+
+    ComponentDependencyModelEntity retrieved =
+        componentDependencyModelManager.get(VSP_ID, VERSION, COMP_DEP_ID);
+
+    Assert.assertEquals(retrieved.getSourceComponentId(), COMP_ID_1);
+
   }
 
   private ComponentDependencyModelEntity createModelEntity(String sourceId, String targetId) {
     ComponentDependencyModelEntity entity =
-        new ComponentDependencyModelEntity(vsp1Id, VERSION01, modelId);
+        new ComponentDependencyModelEntity(VSP_ID, VERSION, COMP_DEP_ID);
     entity.setSourceComponentId(sourceId);
     entity.setTargetComponentId(targetId);
     entity.setRelation("dependsOn");
     return entity;
   }
 
-  private Collection<ComponentDependencyModelEntity> getDependencyModel(String vspId,
-                                                                        Version version,
-                                                                        String user) {
-    return componentDependencyModelManager.list(vspId, version, user);
+  private void testCreateDependency_negative(ComponentDependencyModelEntity entity, String vspId,
+                                             Version version, String expectedErrorCode,
+                                             String expectedErrorMsg) {
+    try {
+      componentDependencyModelManager.createComponentDependency(entity, vspId, version);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
+      Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
+    }
   }
 
-  private void testCreate_negative(List<ComponentDependencyModelEntity> entities, String vspId,
-                                   Version version, String user,
-                                   String expectedErrorCode, String expectedErrorMsg) {
+  private void testUpdateDependency_negative(ComponentDependencyModelEntity entity,
+                                             String expectedErrorCode, String expectedErrorMsg) {
     try {
-      componentDependencyModelManager.createComponentDependencyModel(entities, vspId, version,
-        user);
+      componentDependencyModelManager.update(entity);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
       Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
     }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImplTest.java
index ee8295cafc..c7aa81873b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComponentManagerImplTest.java
@@ -2,12 +2,9 @@ package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.NicManager;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
@@ -37,16 +34,13 @@ import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 
 public class ComponentManagerImplTest {
-
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
-
-  private static final String COMP_NOT_EXIST_MSG =
-      "Vendor Software Product Component with Id 1 does not exist for Vendor Software Product with id VSP_ID and version 0.1";
-  private static final String USER = "componentsTestUser";
   private static final String VSP_ID = "VSP_ID";
-  private static final Version VERSION = new Version(0, 1);
-  private static final String COMP1_ID = "1";
-  private static final String COMP2_ID = "2";
+  private static final Version VERSION = new Version("version_id");
+  private static final String COMP1_ID = "comp1";
+  private static final String COMP2_ID = "comp2";
+  private static final String COMP_NOT_EXIST_MSG =
+      "Vendor Software Product Component with Id comp1 does not exist " +
+          "for Vendor Software Product with id VSP_ID and version version_id";
 
   @Mock
   private ComponentDao componentDaoMock;
@@ -67,20 +61,15 @@ public class ComponentManagerImplTest {
 
   @Test
   public void testListWhenNone() {
-    Collection<ComponentEntity> components =
-        componentManager.listComponents(VSP_ID, VERSION, USER);
+    Collection<ComponentEntity> components = componentManager.listComponents(VSP_ID, VERSION);
     Assert.assertEquals(components.size(), 0);
   }
 
   @Test(expectedExceptions = CoreException.class,
-      expectedExceptionsMessageRegExp = "Vendor Software Product Component with Id dummyComponentId " +
-          "does not exist for Vendor Software Product with id dummyVsp and version 1.0")
+      expectedExceptionsMessageRegExp = COMP_NOT_EXIST_MSG)
   public void validateExceptionWhenTryingToRetriveNotExistingComponentEntity() {
-    Version version = Mockito.mock(Version.class);
-    doReturn("1.0").when(version).toString();
     doReturn(null).when(componentDaoMock).get(anyObject());
-    componentManager.validateComponentExistence("dummyVsp", version, "dummyComponentId",
-        "dummyUser");
+    componentManager.validateComponentExistence(VSP_ID, VERSION, COMP1_ID);
   }
 
   @Test
@@ -90,21 +79,20 @@ public class ComponentManagerImplTest {
         createComponent(VSP_ID, VERSION, COMP2_ID)))
         .when(componentDaoMock).list(anyObject());
 
-    Collection<ComponentEntity> actual =
-        componentManager.listComponents(VSP_ID, VERSION, USER);
+    Collection<ComponentEntity> actual = componentManager.listComponents(VSP_ID, VERSION);
     Assert.assertEquals(actual.size(), 2);
   }
 
   @Test
   public void testDeleteListOnUploadVsp_negative() {
-    testDeleteList_negative(VSP_ID, VERSION, USER,
+    testDeleteList_negative(VSP_ID, VERSION,
         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
   }
 
-/*    @Test
-    public void testCreate() {
-        COMP1_ID = testCreate(VSP_ID);
-    }*/
+  /*    @Test
+      public void testCreate() {
+          COMP1_ID = testCreate(VSP_ID);
+      }*/
   @Test
   public void testCreate() {
     ComponentEntity expected = new ComponentEntity(VSP_ID, null, null);
@@ -113,12 +101,12 @@ public class ComponentManagerImplTest {
     compData.setDescription("comp1 desc");
     expected.setComponentCompositionData(compData);
 
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
     doReturn(expected).when(compositionEntityDataManagerMock).createComponent(anyObject());
 
-    ComponentEntity created = componentManager.createComponent(expected, USER);
+    ComponentEntity created = componentManager.createComponent(expected);
     Assert.assertNotNull(created);
     //expected.setId(created.getId());
     //expected.setVersion(VERSION);
@@ -137,15 +125,14 @@ public class ComponentManagerImplTest {
     compData.setDescription("comp1 desc");
     expected.setComponentCompositionData(compData);
 
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
     vspComponentList.add(expected);
     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
 
     try {
-      ComponentEntity created = componentManager.createComponent(expected, USER);
-    }  catch (CoreException exception) {
-      log.debug("",exception);
+      ComponentEntity created = componentManager.createComponent(expected);
+    } catch (CoreException exception) {
       Assert.assertEquals("Creation of only one VFC per VSP allowed.", exception.code().message());
       Assert.assertEquals(VendorSoftwareProductErrorCodes.VSP_VFC_COUNT_EXCEED,
           exception.code().id());
@@ -161,14 +148,14 @@ public class ComponentManagerImplTest {
     expected.setComponentCompositionData(compData);
 
     doReturn(expected).when(componentDaoMock).get(anyObject());
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
     vspComponentList.add(expected);
     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
-    doReturn(new CompositionEntityValidationData(null,null)).when(compositionEntityDataManagerMock)
-        .validateEntity(anyObject(),anyObject(),anyObject());
+    doReturn(new CompositionEntityValidationData(null, null)).when(compositionEntityDataManagerMock)
+        .validateEntity(anyObject(), anyObject(), anyObject());
 
-    CompositionEntityValidationData created = componentManager.updateComponent(expected, USER);
+    CompositionEntityValidationData created = componentManager.updateComponent(expected);
     Assert.assertNotNull(created);
   }
 
@@ -182,20 +169,19 @@ public class ComponentManagerImplTest {
     expected.setComponentCompositionData(compData);
 
     doReturn(expected).when(componentDaoMock).get(anyObject());
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<ComponentEntity> vspComponentList = new ArrayList<>();
     vspComponentList.add(expected);
-    ComponentEntity expected2 = new ComponentEntity(VSP_ID+"2", null, COMP1_ID+"2");
+    ComponentEntity expected2 = new ComponentEntity(VSP_ID + "2", null, COMP1_ID + "2");
     expected2.setComponentCompositionData(compData);
     vspComponentList.add(expected2);
     doReturn(vspComponentList).when(componentDaoMock).list(anyObject());
-    doReturn(new CompositionEntityValidationData(null,null)).when(compositionEntityDataManagerMock)
-        .validateEntity(anyObject(),anyObject(),anyObject());
+    doReturn(new CompositionEntityValidationData(null, null)).when(compositionEntityDataManagerMock)
+        .validateEntity(anyObject(), anyObject(), anyObject());
 
     try {
-      CompositionEntityValidationData created = componentManager.updateComponent(expected, USER);
-    }  catch (CoreException exception) {
-      log.debug("",exception);
+      CompositionEntityValidationData created = componentManager.updateComponent(expected);
+    } catch (CoreException exception) {
       Assert.assertEquals("VFC with specified name already present in given VSP.",
           exception.code().message());
       Assert.assertEquals(VendorSoftwareProductErrorCodes.VSP_VFC_DUPLICATE_NAME,
@@ -220,7 +206,7 @@ public class ComponentManagerImplTest {
 
   @Test
   public void testCreateOnUploadVsp_negative() {
-    testCreate_negative(new ComponentEntity(VSP_ID, VERSION, null), USER,
+    testCreate_negative(new ComponentEntity(VSP_ID, VERSION, null),
         VendorSoftwareProductErrorCodes.VFC_ADD_NOT_ALLOWED_IN_HEAT_ONBOARDING);
   }
 
@@ -229,7 +215,7 @@ public class ComponentManagerImplTest {
     String componentId = "non existing component id";
     doReturn(null).when(componentDaoMock).get(anyObject());
 
-    testUpdate_negative(VSP_ID, VERSION, componentId, USER,
+    testUpdate_negative(VSP_ID, VERSION, componentId,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -254,7 +240,7 @@ public class ComponentManagerImplTest {
 
 
     CompositionEntityValidationData validationData =
-        componentManager.updateComponent(component, USER);
+        componentManager.updateComponent(component);
     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
     verify(componentDaoMock).update(component);
   }
@@ -277,7 +263,7 @@ public class ComponentManagerImplTest {
     component.setComponentCompositionData(compData);
 
     CompositionEntityValidationData validationData =
-        componentManager.updateComponent(component, USER);
+        componentManager.updateComponent(component);
     Assert.assertNotNull(validationData);
     Assert.assertEquals(validationData.getErrors().size(), 2);
 
@@ -289,7 +275,7 @@ public class ComponentManagerImplTest {
     String componentId = "non existing component id";
     doReturn(null).when(componentDaoMock).get(anyObject());
 
-    testGet_negative(VSP_ID, VERSION, componentId, USER,
+    testGet_negative(VSP_ID, VERSION, componentId,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -300,7 +286,7 @@ public class ComponentManagerImplTest {
 
     doReturn("schema string").when(componentManager).getComponentCompositionSchema(anyObject());
 
-    testGet(VSP_ID, VERSION, COMP1_ID, USER, expected);
+    testGet(VSP_ID, VERSION, COMP1_ID, expected);
   }
 
 
@@ -329,14 +315,14 @@ public class ComponentManagerImplTest {
 
   @Test
   public void testDeleteOnUploadVsp_negative() {
-    testDelete_negative(VSP_ID, VERSION, COMP1_ID, USER,
+    testDelete_negative(VSP_ID, VERSION, COMP1_ID,
         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
   }
 
   @Test(expectedExceptions = CoreException.class,
       expectedExceptionsMessageRegExp = COMP_NOT_EXIST_MSG)
   public void testGetNonExistingComponentQuestionnaire() throws Exception {
-    componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID, USER);
+    componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID);
   }
 
   @Test
@@ -347,7 +333,7 @@ public class ComponentManagerImplTest {
     doReturn(schema).when(componentManager).getComponentQuestionnaireSchema(anyObject());
 
     QuestionnaireResponse questionnaire =
-        componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID, USER);
+        componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID);
     Assert.assertNotNull(questionnaire);
     Assert.assertEquals(questionnaire.getData(), null);
     Assert.assertEquals(questionnaire.getSchema(), schema);
@@ -372,13 +358,13 @@ public class ComponentManagerImplTest {
     nicEntity2.setNicCompositionData(nic2);
 
     doReturn(Arrays.asList(nicEntity1, nicEntity2))
-        .when(nicManagerMock).listNics(VSP_ID, VERSION, COMP1_ID, USER);
+        .when(nicManagerMock).listNics(VSP_ID, VERSION, COMP1_ID);
 
     String schema = "schema string";
     doReturn(schema).when(componentManager).getComponentQuestionnaireSchema(anyObject());
 
     QuestionnaireResponse questionnaire =
-        componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID, USER);
+        componentManager.getQuestionnaire(VSP_ID, VERSION, COMP1_ID);
     Assert.assertNotNull(questionnaire);
     Assert.assertEquals(questionnaire.getData(), component.getQuestionnaireData());
     Assert.assertEquals(questionnaire.getSchema(), schema);
@@ -389,7 +375,7 @@ public class ComponentManagerImplTest {
       expectedExceptionsMessageRegExp = COMP_NOT_EXIST_MSG)
   public void testUpdateNonExistingComponentQuestionnaire() throws Exception {
     doReturn(null).when(componentDaoMock).get(anyObject());
-    componentManager.updateQuestionnaire(VSP_ID, VERSION, COMP1_ID, "questionnaire data", USER);
+    componentManager.updateQuestionnaire(VSP_ID, VERSION, COMP1_ID, "questionnaire data");
   }
 
   @Test
@@ -397,7 +383,7 @@ public class ComponentManagerImplTest {
     ComponentEntity component = createComponent(VSP_ID, VERSION, COMP1_ID);
     doReturn(component).when(componentDaoMock).get(anyObject());
 
-    componentManager.updateQuestionnaire(VSP_ID, VERSION, COMP1_ID, "questionnaire data", USER);
+    componentManager.updateQuestionnaire(VSP_ID, VERSION, COMP1_ID, "questionnaire data");
 
     verify(componentDaoMock)
         .updateQuestionnaireData(VSP_ID, VERSION, COMP1_ID, "questionnaire data");
@@ -417,79 +403,72 @@ public class ComponentManagerImplTest {
         Assert.assertEquals(actual.size(), 0);
     }*/
 
-  private void testGet(String vspId, Version version, String componentId, String user,
+  private void testGet(String vspId, Version version, String componentId,
                        ComponentEntity expected) {
 
     CompositionEntityResponse<ComponentData>
-        response = componentManager.getComponent(vspId, version, componentId, user);
+        response = componentManager.getComponent(vspId, version, componentId);
     Assert.assertEquals(response.getId(), expected.getId());
     Assert.assertEquals(response.getData(), expected.getComponentCompositionData());
     Assert.assertNotNull(response.getSchema());
   }
 
-  private void testCreate_negative(ComponentEntity component, String user,
+  private void testCreate_negative(ComponentEntity component,
                                    String expectedErrorCode) {
     try {
-      componentManager.createComponent(component, user);
+      componentManager.createComponent(component);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testGet_negative(String vspId, Version version, String componentId, String user,
+  private void testGet_negative(String vspId, Version version, String componentId,
                                 String expectedErrorCode) {
     try {
-      componentManager.getComponent(vspId, version, componentId, user);
+      componentManager.getComponent(vspId, version, componentId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testUpdate_negative(String vspId, Version version, String componentId, String user,
+  private void testUpdate_negative(String vspId, Version version, String componentId,
                                    String expectedErrorCode) {
     try {
-      componentManager
-          .updateComponent(new ComponentEntity(vspId, version, componentId), user);
+      componentManager.updateComponent(new ComponentEntity(vspId, version, componentId));
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testList_negative(String vspId, Version version, String user,
+  private void testList_negative(String vspId, Version version,
                                  String expectedErrorCode) {
     try {
-      componentManager.listComponents(vspId, version, user);
+      componentManager.listComponents(vspId, version);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testDeleteList_negative(String vspId, Version version, String user,
+  private void testDeleteList_negative(String vspId, Version version,
                                        String expectedErrorCode) {
     try {
-      componentManager.deleteComponents(vspId, version, user);
+      componentManager.deleteComponents(vspId, version);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testDelete_negative(String vspId, Version version, String componentId, String user,
+  private void testDelete_negative(String vspId, Version version, String componentId,
                                    String expectedErrorCode) {
     try {
-      componentManager.deleteComponent(vspId, version, componentId, user);
+      componentManager.deleteComponent(vspId, version, componentId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImplTest.java
index eda5693cce..9058a73632 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ComputeManagerImplTest.java
@@ -1,378 +1,348 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.NetworkManager;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
 import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.ListComputeResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.QuestionnaireResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComputeData;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
 import org.openecomp.sdc.versioning.dao.types.Version;
 import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.List;
 
-public class ComputeManagerImplTest {
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
-    private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+public class ComputeManagerImplTest {
 
-    private static final String COMPUTE_NOT_EXIST_MSG =
-            "Vendor Software Product COMPUTE with Id compute1 does not exist for Vendor Software Product with " +
-                    "id VSP_ID and version 0.1";
+  private static final String COMPUTE_NOT_EXIST_MSG =
+      "Vendor Software Product COMPUTE with Id compute1 does not exist for Vendor Software Product with " +
+          "id VSP_ID and version version_id";
 
-    private static final String USER = "computeTestUser";
-    private static final String VSP_ID = "VSP_ID";
-    private static final Version VERSION = new Version(0, 1);
-    private static final String COMPONENT_ID = "COMPONENT_ID";
-    private static final String COMPUTE1_ID = "compute1";
-    private static final String COMPUTE2_ID = "compute2";
+  private static final String VSP_ID = "VSP_ID";
+  private static final Version VERSION = new Version("version_id");
+  private static final String COMPONENT_ID = "COMPONENT_ID";
+  private static final String COMPUTE1_ID = "compute1";
+  private static final String COMPUTE2_ID = "compute2";
 
   @Mock
   private ComputeDao computeDao;
-
   @Mock
   private CompositionEntityDataManager compositionEntityDataManagerMock;
-
-  @Mock
-  private NetworkManager networkManagerMock;
-
   @Mock
   private VendorSoftwareProductInfoDao vspInfoDao;
-
-  @Mock
-  private ComputeEntity computeEntity;
-
-  @Mock
-  private ListComputeResponse listComputeResponse;
-
-  @Mock
-  private DeploymentFlavorEntity deploymentFlavorEntity;
-
   @Mock
   private DeploymentFlavorDao deploymentFlavorDao;
-
-  @Mock
-  private ComponentComputeAssociation componentComputeAssociation;
-
-  @Mock
-  DeploymentFlavor deploymentFlavor;
-
   @InjectMocks
   @Spy
   private ComputeManagerImpl computeManager;
 
   @BeforeMethod
   public void setUp() throws Exception {
-      MockitoAnnotations.initMocks(this);
+    MockitoAnnotations.initMocks(this);
   }
 
-   @Test
+  @Test
   public void testListWhenNone() {
-    Collection<ListComputeResponse> computes = computeManager.listCompute(VSP_ID, VERSION, COMPONENT_ID, USER);
+    Collection<ListComputeResponse> computes =
+        computeManager.listComputes(VSP_ID, VERSION, COMPONENT_ID);
     Assert.assertEquals(computes.size(), 0);
   }
 
   @Test
-  public void testList(){
-      doReturn(Arrays.asList(
+  public void testList() {
+    doReturn(Arrays.asList(
         createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID),
         createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE2_ID)))
-              .when(computeDao).list(anyObject());
-
+        .when(computeDao).list(anyObject());
 
-      Collection<ListComputeResponse> computes = computeManager.listCompute(VSP_ID, VERSION, COMPONENT_ID, USER);
-      Assert.assertEquals(computes.size(), 2);
-      for (ListComputeResponse compute : computes) {
-          Assert.assertEquals(compute.getComputeEntity().getComputeCompositionData().getName(),
-                  COMPUTE1_ID.equals(compute.getComputeEntity().getId())
-                          ? "compute1name"
-                          : "compute2name");
-      };
-  }
 
-    @Test
-    public void testCreateOnNotManualCompute_negative() {
-
-        testCreate_negative(new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, null), USER,
-                VendorSoftwareProductErrorCodes.ADD_COMPUTE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
-    }
-
-    @Test
-    public void testCreateManualCompute() {
-        ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-        computeManager.createCompute(expected, USER);
-        verify(compositionEntityDataManagerMock).createCompute(expected);
-        verify(compositionEntityDataManagerMock).createCompute(expected);
-    }
-
-    @Test
-    public void testCreateManualComputeWithDuplicateName() {
-        ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-        ComputeEntity expectedDiffName = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        expectedDiffName.setId(COMPUTE1_ID + "Name");
-        ComputeData computeData = expectedDiffName.getComputeCompositionData();
-        computeData.setName(COMPUTE1_ID + "Name");
-        expectedDiffName.setComputeCompositionData(computeData);
-        List<ComputeEntity> vfcImageList = new ArrayList<ComputeEntity>();
-        vfcImageList.add(expectedDiffName);
-        doReturn(vfcImageList).when(computeDao).list(anyObject());
-
-        try {
-            computeManager.createCompute(expected, USER);
-            Assert.fail();
-        }
-        catch (CoreException ex) {
-          log.debug("",ex);
-            Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_COMPUTE_NAME_NOT_ALLOWED,
-                    ex.code().id());
-        }
-    }
-
-    @Test
-    public void testUpdateNonExistingComputeId_negative() {
-
-        testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER,
-                VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+    Collection<ListComputeResponse> computes =
+        computeManager.listComputes(VSP_ID, VERSION, COMPONENT_ID);
+    Assert.assertEquals(computes.size(), 2);
+    for (ListComputeResponse compute : computes) {
+      Assert.assertEquals(compute.getComputeEntity().getComputeCompositionData().getName(),
+          COMPUTE1_ID.equals(compute.getComputeEntity().getId())
+              ? "compute1name"
+              : "compute2name");
     }
+  }
 
-    @Test
-    public void testUpdateCompute() {
-        doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
-                .when(computeDao).get(anyObject());
-
-        doReturn(new CompositionEntityValidationData(CompositionEntityType.compute, COMPUTE1_ID))
-                .when(compositionEntityDataManagerMock)
-                .validateEntity(anyObject(), anyObject(), anyObject());
-
-        ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        ComputeData computeData = new ComputeData();
-        computeData.setName(COMPUTE1_ID + "name");
-        computeData.setDescription(COMPUTE1_ID + "desc updated");
-        computeEntity.setComputeCompositionData(computeData);
-
-        CompositionEntityValidationData validationData =
-                computeManager.updateCompute(computeEntity, USER);
-        Assert.assertTrue(validationData == null || validationData.getErrors() == null);
-        verify(computeDao).update(computeEntity);
-    }
+  @Test
+  public void testCreateOnNotManualCompute_negative() {
+    testCreate_negative(new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, null),
+        VendorSoftwareProductErrorCodes.ADD_COMPUTE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
+  }
 
-    @Test
-    public void testIllegalComputeUpdate() {
-        doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
-                .when(computeDao).get(anyObject());
+  @Test
+  public void testCreateManualCompute() {
+    ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
+    doNothing().when(computeManager)
+        .validateUniqueName(VSP_ID, VERSION, COMPONENT_ID,
+            expected.getComputeCompositionData().getName());
+    doNothing().when(computeManager)
+        .createUniqueName(VSP_ID, VERSION, COMPONENT_ID,
+            expected.getComputeCompositionData().getName());
+    String questionnaireSchema = "{}";
+    doReturn(questionnaireSchema).when(computeManager).getComputeQuestionnaireSchema(anyObject());
+
+    computeManager.createCompute(expected);
+    verify(computeDao).create(expected);
+  }
 
-        doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
+  @Test(expectedExceptions = CoreException.class)
+  public void testCreateManualComputeWithDuplicateName() {
+    ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 
-        CompositionEntityValidationData toBeReturned =
-                new CompositionEntityValidationData(CompositionEntityType.compute, COMPUTE1_ID);
-        toBeReturned.setErrors(Arrays.asList("error1", "error2"));
-        doReturn(toBeReturned)
-                .when(compositionEntityDataManagerMock)
-                .validateEntity(anyObject(), anyObject(), anyObject());
+    doThrow(new CoreException(
+        new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
+        .when(computeManager).validateUniqueName(VSP_ID, VERSION, COMPONENT_ID,
+        expected.getComputeCompositionData().getName());
 
-        ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        ComputeData computeData = new ComputeData();
-        computeData.setName(COMPUTE1_ID + "_name_updated");
-        computeData.setDescription(COMPUTE1_ID + " desc updated");
-        computeEntity.setComputeCompositionData(computeData);
+    computeManager.createCompute(expected);
+  }
 
-        CompositionEntityValidationData validationData = computeManager.updateCompute(computeEntity, USER);
-        Assert.assertNotNull(validationData);
-        Assert.assertEquals(validationData.getErrors().size(), 2);
+  @Test
+  public void testUpdateNonExistingComputeId_negative() {
+    testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
 
-        verify(computeDao, never()).update(computeEntity);
-    }
+  @Test
+  public void testUpdateCompute() {
+    ComputeEntity retrieved = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    doReturn(retrieved).when(computeDao).get(anyObject());
+
+    doReturn(new CompositionEntityValidationData(CompositionEntityType.compute, COMPUTE1_ID))
+        .when(compositionEntityDataManagerMock)
+        .validateEntity(anyObject(), anyObject(), anyObject());
+
+    ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    ComputeData computeData = new ComputeData();
+    computeData.setName(COMPUTE1_ID + "name");
+    computeData.setDescription(COMPUTE1_ID + "desc updated");
+    computeEntity.setComputeCompositionData(computeData);
+
+    doNothing().when(computeManager)
+        .updateUniqueName(VSP_ID, VERSION, COMPONENT_ID, retrieved.getComputeCompositionData().getName(),
+            computeData.getName());
+
+    CompositionEntityValidationData validationData =
+        computeManager.updateCompute(computeEntity);
+    Assert.assertTrue(validationData == null || validationData.getErrors() == null);
+    verify(computeDao).update(computeEntity);
+  }
 
-    @Test
-    public void testUpdateHEATComputeName() throws Exception {
-        doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
-                .when(computeDao).get(anyObject());
-        ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        ComputeData computeData = new ComputeData();
-        computeData.setName(COMPUTE1_ID + " name updated");
-        computeData.setDescription(COMPUTE1_ID + " desc updated");
-        computeEntity.setComputeCompositionData(computeData);
-
-        try {
-            computeManager.updateCompute(computeEntity, USER);
-        }
-        catch (CoreException ex) {
-          log.debug("",ex);
-            Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_COMPUTE_NOT_ALLOWED);
-        }
+  @Test
+  public void testIllegalComputeUpdate() {
+    doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
+        .when(computeDao).get(anyObject());
+
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
+
+    CompositionEntityValidationData toBeReturned =
+        new CompositionEntityValidationData(CompositionEntityType.compute, COMPUTE1_ID);
+    toBeReturned.setErrors(Arrays.asList("error1", "error2"));
+    doReturn(toBeReturned)
+        .when(compositionEntityDataManagerMock)
+        .validateEntity(anyObject(), anyObject(), anyObject());
+
+    ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    ComputeData computeData = new ComputeData();
+    computeData.setName(COMPUTE1_ID + "_name_updated");
+    computeData.setDescription(COMPUTE1_ID + " desc updated");
+    computeEntity.setComputeCompositionData(computeData);
+
+    CompositionEntityValidationData validationData =
+        computeManager.updateCompute(computeEntity);
+    Assert.assertNotNull(validationData);
+    Assert.assertEquals(validationData.getErrors().size(), 2);
+
+    verify(computeDao, never()).update(computeEntity);
+  }
 
+  @Test
+  public void testUpdateHEATComputeName() throws Exception {
+    doReturn(createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID))
+        .when(computeDao).get(anyObject());
+    ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    ComputeData computeData = new ComputeData();
+    computeData.setName(COMPUTE1_ID + " name updated");
+    computeData.setDescription(COMPUTE1_ID + " desc updated");
+    computeEntity.setComputeCompositionData(computeData);
+
+    try {
+      computeManager.updateCompute(computeEntity);
+    } catch (CoreException ex) {
+      Assert
+          .assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_COMPUTE_NOT_ALLOWED);
     }
+  }
 
-    @Test
-    public void testUpdateManualComputeQuestionnaire() throws Exception {
-        String json = "{\"md5\" :\"FFDSD33SS\"}";
-        doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-        doReturn(new ComputeEntity(null,null,null,null)).when(computeDao).get(anyObject());
+  @Test
+  public void testUpdateManualComputeQuestionnaire() throws Exception {
+    String json = "{\"md5\" :\"FFDSD33SS\"}";
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
+    doReturn(new ComputeEntity(null, null, null, null)).when(computeDao).get(anyObject());
+
+    computeManager
+        .updateComputeQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, json);
+    verify(computeDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, json);
+  }
 
-        computeManager.updateComputeQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, json, USER);
-        verify(computeDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, json);
-    }
+  @Test
+  public void testGetNonExistingComputeId_negative() {
+    testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing compute id",
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+  }
 
-    @Test
-    public void testGetNonExistingComputeId_negative() {
-        testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing compute id", USER,
-                VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
-    }
+  @Test
+  public void testGet() {
+    ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    doReturn(expected).when(computeDao).get(anyObject());
+    String compositionSchema = "schema string";
+    doReturn(compositionSchema).when(computeManager).getComputeCompositionSchema(anyObject());
+
+    CompositionEntityResponse<ComputeData> response =
+        computeManager.getCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    Assert.assertEquals(response.getId(), expected.getId());
+    Assert
+        .assertEquals(response.getData().getName(), expected.getComputeCompositionData().getName());
+    Assert.assertEquals(response.getData().getDescription(), expected.getComputeCompositionData().
+        getDescription());
+    Assert.assertEquals(response.getSchema(), compositionSchema);
+  }
 
-    @Test
-    public void testGet() {
-        ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        doReturn(expected).when(computeDao).get(anyObject());
-        String compositionSchema = "schema string";
-        doReturn(compositionSchema).when(computeManager).getComputeCompositionSchema(anyObject());
-
-        CompositionEntityResponse<ComputeData> response =
-                computeManager.getCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER);
-        Assert.assertEquals(response.getId(), expected.getId());
-        Assert.assertEquals(response.getData().getName(), expected.getComputeCompositionData().getName());
-        Assert.assertEquals(response.getData().getDescription(), expected.getComputeCompositionData().
-                getDescription());
-        Assert.assertEquals(response.getSchema(), compositionSchema);
-    }
+  @Test
+  public void testGetQuestionnaire() throws Exception {
+    ComputeEntity compute = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    compute.setQuestionnaireData("{}");
+    doReturn(compute).when(computeDao)
+        .getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 
-    @Test
-    public void testGetQuestionnaire() throws Exception {
-        ComputeEntity compute = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        compute.setQuestionnaireData("{}");
-        doReturn(compute).when(computeDao).getQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    String schema = "schema string";
 
-        String schema = "schema string";
+    doReturn(schema).when(computeManager).getComputeQuestionnaireSchema(anyObject());
 
+    QuestionnaireResponse questionnaire =
+        computeManager.getComputeQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
 
-        doReturn(schema).when(computeManager).getComputeQuestionnaireSchema(anyObject());
+    Assert.assertNotNull(questionnaire);
+    Assert.assertEquals(questionnaire.getData(), compute.getQuestionnaireData());
+    Assert.assertEquals(questionnaire.getSchema(), schema);
+    Assert.assertNull(questionnaire.getErrorMessage());
+  }
 
-        QuestionnaireResponse questionnaire =
-                computeManager.getComputeQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER);
+  @Test
+  public void testDeleteOnNotManualCompute() {
+    ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    doReturn(expected).when(computeDao).get(anyObject());
+    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID,
+        VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
+  }
 
-        Assert.assertNotNull(questionnaire);
-        Assert.assertEquals(questionnaire.getData(), compute.getQuestionnaireData());
-        Assert.assertEquals(questionnaire.getSchema(), schema);
-        Assert.assertNull(questionnaire.getErrorMessage());
-    }
+  @Test
+  public void testDeleteOnManualCompute() {
+    ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    doReturn(expected).when(computeDao).get(anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
+    doNothing().when(computeManager).deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID,
+        expected.getComputeCompositionData().getName());
+
+    computeManager.deleteCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
+    verify(computeDao).delete(anyObject());
+  }
 
-    @Test
-    public void testDeleteOnNotManualCompute() {
-        ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        doReturn(expected).when(computeDao).get(anyObject());
-        testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER,
-                VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
-    }
+  @Test
+  public void testDeleteOnNotExistCompute() {
+    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID,
+        VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
+  }
 
-    @Test
-    public void testDeleteOnManualCompute() {
-        ComputeEntity expected = createCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID);
-        doReturn(expected).when(computeDao).get(anyObject());
-        doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-        computeManager.deleteCompute(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER);
-        verify(computeDao).delete(anyObject());
-    }
 
-    @Test
-    public void testDeleteOnNotExistCompute() {
-        testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, COMPUTE1_ID, USER,
-                VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
+  private void testDelete_negative(String vspId, Version version, String componentId,
+                                   String computeId,
+                                   String expectedErrorCode) {
+    try {
+      computeManager.deleteCompute(vspId, version, componentId, computeId);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
+  }
 
-
-    private void testDelete_negative(String vspId, Version version, String componentId, String computeId,
-                                     String user,
-                                     String expectedErrorCode) {
-        try {
-            computeManager.deleteCompute(vspId, version, componentId, computeId, user);
-            Assert.fail();
-        } catch (CoreException exception) {
-          log.debug("",exception);
-            Assert.assertEquals(exception.code().id(), expectedErrorCode);
-        }
+  private void testGet_negative(String vspId, Version version, String componentId, String computeId,
+                                String expectedErrorCode) {
+    try {
+      computeManager.getCompute(vspId, version, componentId, computeId);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
-
-    private void testGet_negative(String vspId, Version version, String componentId, String computeId,
-                                String user, String expectedErrorCode) {
-      try {
-          computeManager.getCompute(vspId, version, componentId, computeId, user);
-          Assert.fail();
-      } catch (CoreException exception) {
-        log.debug("",exception);
-          Assert.assertEquals(exception.code().id(), expectedErrorCode);
-      }
   }
 
-    private void testList_negative(String vspId, Version version, String componentId, String user,
-                                   String expectedErrorCode, String expectedErrorMsg) {
-        try {
-            computeManager.listCompute(vspId, version, componentId, user);
-            Assert.fail();
-        } catch (CoreException exception) {
-          log.debug("",exception);
-            Assert.assertEquals(exception.code().id(), expectedErrorCode);
-            Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
-        }
+  private void testList_negative(String vspId, Version version, String componentId,
+                                 String expectedErrorCode, String expectedErrorMsg) {
+    try {
+      computeManager.listComputes(vspId, version, componentId);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
+      Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
     }
+  }
 
 
-
-    private void testUpdate_negative(String vspId, Version version, String componentId, String computeId,
-                                 String user, String expectedErrorCode) {
-  try {
-    computeManager.updateCompute(new ComputeEntity(vspId, version, componentId, computeId), user);
-    Assert.fail();
-  } catch (CoreException exception) {
-    log.debug("",exception);
+  private void testUpdate_negative(String vspId, Version version, String componentId,
+                                   String computeId, String expectedErrorCode) {
+    try {
+      computeManager.updateCompute(new ComputeEntity(vspId, version, componentId, computeId));
+      Assert.fail();
+    } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testCreate_negative(ComputeEntity computeEntity1, String user, String expectedErrorCode) {
-        try {
-            computeManager.createCompute(computeEntity1, user);
-            Assert.fail();
-        } catch (CoreException exception) {
-          log.debug("",exception);
-            Assert.assertEquals(exception.code().id(), expectedErrorCode);
-        }
+  private void testCreate_negative(ComputeEntity computeEntity1, String expectedErrorCode) {
+    try {
+      computeManager.createCompute(computeEntity1);
+      Assert.fail();
+    } catch (CoreException exception) {
+      Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
+  }
 
-  static ComputeEntity createCompute(String vspId, Version version, String compId, String computeId){
-      ComputeEntity computeEntity1 = new ComputeEntity(vspId, version, compId, computeId);
-      ComputeData computeData = new ComputeData();
-      computeData.setName(computeId+"name");
-      computeData.setDescription(computeId+"desc");
-      computeEntity1.setComputeCompositionData(computeData);
-      return computeEntity1;
+  private static ComputeEntity createCompute(String vspId, Version version, String compId,
+                                             String computeId) {
+    ComputeEntity computeEntity1 = new ComputeEntity(vspId, version, compId, computeId);
+    ComputeData computeData = new ComputeData();
+    computeData.setName(computeId + "name");
+    computeData.setDescription(computeId + "desc");
+    computeEntity1.setComputeCompositionData(computeData);
+    return computeEntity1;
   }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeplomentFlavorManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeplomentFlavorManagerImplTest.java
deleted file mode 100644
index 598b97b34e..0000000000
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeplomentFlavorManagerImplTest.java
+++ /dev/null
@@ -1,463 +0,0 @@
-package org.openecomp.sdc.vendorsoftwareproduct.impl;
-
-
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.verify;
-
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.Spy;
-import org.openecomp.core.utilities.json.JsonUtil;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComputeEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
-import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
-import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
-import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
-import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
-import org.testng.Assert;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-
-public class DeplomentFlavorManagerImplTest {
-  private static final String USER = "depFlavorTestUser";
-  private static final String VSP_ID = "VSP_ID";
-  private static final Version VERSION = new Version(0, 1);
-  private static final String COMPONENT_ID = "COMPONENT_ID";
-  private static final String DF1_ID = "df1";
-  private static final String DF2_ID = "df2";
-
-  @Mock
-  private CompositionEntityDataManager compositionEntityDataManagerMock;
-  @Mock
-  private VendorSoftwareProductInfoDao vspInfoDao;
-  @Mock
-  DeploymentFlavorDao deploymentFlavorDaoMock;
-  @Mock
-  ComponentDao componentDaoMock;
-  @Mock
-  ComputeDao computeDaoMock;
-  @InjectMocks
-  @Spy
-  private DeploymentFlavorManagerImpl deploymentFlavorManager;
-
-  @BeforeMethod
-  public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  @Test
-  public void testListWhenNone() {
-    final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
-        deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION,  USER);
-    Assert.assertEquals(deploymentFlavorEntities.size(), 0);
-  }
-
-  @Test
-  public void testCreateOnNotManual_negative() {
-
-    testCreate_negative(new DeploymentFlavorEntity(VSP_ID, VERSION,  null), USER,
-        VendorSoftwareProductErrorCodes.CREATE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
-  }
-
-  @Test
-  public void testCreateManualDepFlavor() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-    doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-    deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-    verify(compositionEntityDataManagerMock).createDeploymentFlavor(expected);
-  }
-
-  @Test
-  public void testCreateManualDepFlavorWithDuplicateName() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    DeploymentFlavorEntity expectedDiffName = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    DeploymentFlavor deploymentFlavor = expectedDiffName.getDeploymentFlavorCompositionData();
-    deploymentFlavor.setModel(DF1_ID + "Name");
-    expectedDiffName.setDeploymentFlavorCompositionData(deploymentFlavor);
-    List<DeploymentFlavorEntity> list = new ArrayList<DeploymentFlavorEntity>();
-    list.add(expectedDiffName);
-    doReturn(list).when(deploymentFlavorDaoMock).list(anyObject());
-
-    try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-      Assert.fail();
-    }
-    catch (CoreException ex) {
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_DEPLOYMENT_FLAVOR_MODEL_NOT_ALLOWED,
-          ex.code().id());
-    }
-  }
-
-  @Test
-  public void testCreateManualDepFlavorWithIncorrectNameFormat() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    DeploymentFlavorEntity expectedDiffName = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    DeploymentFlavor deploymentFlavor = expectedDiffName.getDeploymentFlavorCompositionData();
-    deploymentFlavor.setModel(DF1_ID + "Name/*");
-    expectedDiffName.setDeploymentFlavorCompositionData(deploymentFlavor);
-    List<DeploymentFlavorEntity> list = new ArrayList<DeploymentFlavorEntity>();
-    list.add(expectedDiffName);
-    doReturn(list).when(deploymentFlavorDaoMock).list(anyObject());
-
-    try {
-      deploymentFlavorManager.createDeploymentFlavor(expectedDiffName, USER);
-      Assert.fail();
-    }
-    catch (CoreException ex) {
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.DEPLOYMENT_FLAVOR_NAME_FORMAT_NOT_ALLOWED,
-              ex.code().id());
-    }
-  }
-  @Test
-  public void testCreateManualDepFlavorWithFGNotInVSP() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    final DeploymentFlavor deploymentFlavor =
-        JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
-    deploymentFlavor.setFeatureGroupId("fg3");
-    expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
-
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    List<String> featureGrps = new ArrayList<String>();
-    featureGrps.add("fg1");
-    featureGrps.add("fg2");
-
-    VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-    vspDetails.setFeatureGroups(featureGrps);
-    doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-
-    try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-      Assert.fail();
-    }
-    catch (CoreException ex) {
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.FEATURE_GROUP_NOT_EXIST_FOR_VSP,
-          ex.code().id());
-    }
-  }
-
-  @Test
-  public void testCreateManualDepFlavorWithNullCompInAssociation() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
-    final DeploymentFlavor deploymentFlavor =
-        JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
-    ComponentComputeAssociation association = new ComponentComputeAssociation();
-    association.setComponentId(null);
-    association.setComputeFlavorId("CF1");
-    List<ComponentComputeAssociation> list = new ArrayList<ComponentComputeAssociation>();
-    list.add(association);
-    deploymentFlavor.setComponentComputeAssociations(list);
-    expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
-
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-    doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-    try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-    }
-    catch (CoreException ex) {
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPONENT_COMPUTE_ASSOCIATION,
-          ex.code().id());
-      Assert.assertEquals("Invalid request,for valid association please provide ComponentId for Compute Flavor",
-          ex.getMessage());
-    }
-  }
-
-  @Test
-  public void testCreateManualDepFlavorWithInvalidComputeInAssociation() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
-    final DeploymentFlavor deploymentFlavor =
-        JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
-    ComponentComputeAssociation association = new ComponentComputeAssociation();
-    association.setComponentId(COMPONENT_ID);
-    association.setComputeFlavorId("CF1");
-    List<ComponentComputeAssociation> list = new ArrayList<ComponentComputeAssociation>();
-    list.add(association);
-    deploymentFlavor.setComponentComputeAssociations(list);
-    expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
-
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-    doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-    ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, USER);
-    doReturn(component).when(componentDaoMock).get(anyObject());
-
-    doReturn(null).when(computeDaoMock).get(anyObject());
-
-    try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-    }
-    catch (CoreException ex) {
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPUTE_FLAVOR_ID,
-          ex.code().id());
-    }
-  }
-
-  @Test
-  public void testCreateManualDepFlavorWithDuplicateVfcAssociation() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
-    final DeploymentFlavor deploymentFlavor =
-        JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
-    ComponentComputeAssociation association = new ComponentComputeAssociation();
-    association.setComponentId(COMPONENT_ID);
-    association.setComputeFlavorId("CF1");
-    List<ComponentComputeAssociation> list = new ArrayList<ComponentComputeAssociation>();
-    list.add(association);
-    list.add(association);
-    deploymentFlavor.setComponentComputeAssociations(list);
-    expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
-
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-    doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-    ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, USER);
-    doReturn(component).when(componentDaoMock).get(anyObject());
-
-    ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, "CF1");
-    doReturn(computeEntity).when(computeDaoMock).get(anyObject());
-
-    try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-    }
-    catch (CoreException ex) {
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.SAME_VFC_ASSOCIATION_MORE_THAN_ONCE_NOT_ALLOWED,
-          ex.code().id());
-    }
-  }
-
-  @Test
-  public void testList() {
-
-    doReturn(Arrays.asList(
-        createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID),
-        createDeploymentFlavor(VSP_ID, VERSION,  DF2_ID)))
-        .when(deploymentFlavorDaoMock).list(anyObject());
-
-
-    final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
-        deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION,  USER);
-    Assert.assertEquals(deploymentFlavorEntities.size(), 2);
-    for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
-      Assert.assertEquals(deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel()
-          , DF1_ID.equals(deploymentFlavorEntity.getId()) ? DF1_ID+"name" : DF2_ID+"name" );
-    }
-  }
-
-  @Test
-  public void testUpdateHeatDepFlavor() {
-    testUpdate_negative(VSP_ID, VERSION, DF1_ID, USER,
-        VendorSoftwareProductErrorCodes.EDIT_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
-  }
-
-  @Test
-  public void testUpdateNonExistingManualDepFlavorId_negative() {
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-    testUpdate_negative(VSP_ID, VERSION, DF1_ID, USER,
-        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
-  }
-
-  @Test
-  public void testManualUpdateDepFlavor() {
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-    doReturn(createDeploymentFlavor(VSP_ID, VERSION, DF1_ID))
-        .when(deploymentFlavorDaoMock).get(anyObject());
-
-    doReturn(new CompositionEntityValidationData(CompositionEntityType.image, DF1_ID))
-        .when(compositionEntityDataManagerMock)
-        .validateEntity(anyObject(), anyObject(), anyObject());
-
-    VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-    doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-    DeploymentFlavorEntity deploymentFlavorEntity = new DeploymentFlavorEntity(VSP_ID, VERSION, DF1_ID);
-    DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
-    deploymentFlavor.setModel(DF1_ID + "_name");
-    deploymentFlavor.setDescription(DF1_ID + " desc updated");
-    deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
-
-    CompositionEntityValidationData validationData =
-        deploymentFlavorManager.updateDeploymentFlavor(deploymentFlavorEntity, USER);
-    Assert.assertTrue(validationData == null || validationData.getErrors() == null);
-    verify(deploymentFlavorDaoMock).update(deploymentFlavorEntity);
-  }
-
-    @Test
-    public void testManualUpdateDepFlavorIncorrectNameFormat() {
-        doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-
-        doReturn(createDeploymentFlavor(VSP_ID, VERSION, DF1_ID))
-                .when(deploymentFlavorDaoMock).get(anyObject());
-
-        doReturn(new CompositionEntityValidationData(CompositionEntityType.image, DF1_ID))
-                .when(compositionEntityDataManagerMock)
-                .validateEntity(anyObject(), anyObject(), anyObject());
-
-        VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-        doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-        DeploymentFlavorEntity deploymentFlavorEntity = new DeploymentFlavorEntity(VSP_ID, VERSION, DF1_ID);
-        DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
-        deploymentFlavor.setModel(DF1_ID + "_name/*");
-        deploymentFlavor.setDescription(DF1_ID + " desc updated");
-        deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
-
-        try {
-            deploymentFlavorManager.updateDeploymentFlavor(deploymentFlavorEntity, USER);
-            Assert.fail();
-        }
-        catch (CoreException ex) {
-            Assert.assertEquals(VendorSoftwareProductErrorCodes.DEPLOYMENT_FLAVOR_NAME_FORMAT_NOT_ALLOWED,
-                    ex.code().id());
-        }
-    }
-
-  @Test
-  public void testGetNonExistingDepFlavorId_negative() {
-    testGet_negative(VSP_ID, VERSION, "non existing image id", USER,
-        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
-  }
-
-  @Test
-  public void testGet() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
-
-    VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
-    doReturn(vspDetails).when(vspInfoDao).get(anyObject());
-
-    CompositionEntityResponse<DeploymentFlavor> response =
-        deploymentFlavorManager.getDeploymentFlavor(VSP_ID, VERSION, DF1_ID, USER);
-    Assert.assertEquals(response.getId(), expected.getId());
-    Assert.assertEquals(response.getData().getModel(), expected.getDeploymentFlavorCompositionData().
-        getModel());
-    Assert.assertEquals(response.getData().getDescription(), expected.getDeploymentFlavorCompositionData().
-        getDescription());
-  }
-
-  @Test
-  public void testDeleteDepFlavorOnHEAT() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
-    testDelete_negative(VSP_ID, VERSION,  DF1_ID, USER,
-        VendorSoftwareProductErrorCodes.DELETE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
-  }
-
-  @Test
-  public void testDeleteOnNotExistImage() {
-    testDelete_negative(VSP_ID, VERSION,  DF1_ID, USER,
-        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
-  }
-
-  @Test
-  public void testDeleteOnManualImage() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
-    doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
-    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-    deploymentFlavorManager.deleteDeploymentFlavor(VSP_ID, VERSION, DF1_ID, USER);
-    verify(deploymentFlavorDaoMock).delete(anyObject());
-  }
-
-  private void testList_negative(String vspId, Version version, String componentId, String user,
-                                 String expectedErrorCode, String expectedErrorMsg) {
-    try {
-      deploymentFlavorManager.listDeploymentFlavors(vspId, version, user);
-      Assert.fail();
-    } catch (CoreException exception) {
-      Assert.assertEquals(exception.code().id(), expectedErrorCode);
-      Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
-    }
-  }
-
-  private void testCreate_negative(DeploymentFlavorEntity deploymentFlavorEntity, String user, String
-      expectedErrorCode) {
-    try {
-      deploymentFlavorManager.createDeploymentFlavor(deploymentFlavorEntity, user);
-      Assert.fail();
-    } catch (CoreException exception) {
-      Assert.assertEquals(exception.code().id(), expectedErrorCode);
-    }
-  }
-
-  private void testDelete_negative(String vspId, Version version, String deploymentFlavorId,
-                                   String user,
-                                   String expectedErrorCode) {
-    try {
-      deploymentFlavorManager.deleteDeploymentFlavor(vspId, version, deploymentFlavorId, user);
-      Assert.fail();
-    } catch (CoreException exception) {
-      Assert.assertEquals(exception.code().id(), expectedErrorCode);
-    }
-  }
-
-  static DeploymentFlavorEntity createDeploymentFlavor(String vspId, Version version, String deploymentFlavorId) {
-
-    DeploymentFlavorEntity deploymentFlavorEntity = new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
-    DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
-    deploymentFlavor.setModel(deploymentFlavorId + "name");
-    deploymentFlavor.setDescription(deploymentFlavorId + " desc");
-
-    deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
-    return deploymentFlavorEntity;
-  }
-
-  private void testUpdate_negative(String vspId, Version version, String
-      deploymentFlavorId, String user, String expectedErrorCode) {
-    try {
-      DeploymentFlavorEntity deploymentFlavorEntity = new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
-      DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
-      deploymentFlavor.setModel("Name");
-      deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
-      deploymentFlavorManager
-          .updateDeploymentFlavor(deploymentFlavorEntity, user);
-      Assert.fail();
-    } catch (CoreException exception) {
-      Assert.assertEquals(exception.code().id(), expectedErrorCode);
-    }
-  }
-
-  private void testGet_negative(String vspId, Version version, String deploymentFlavorId,
-                                String user, String expectedErrorCode) {
-    try {
-      deploymentFlavorManager.getDeploymentFlavor(vspId, version, deploymentFlavorId, user);
-      Assert.fail();
-    } catch (CoreException exception) {
-      Assert.assertEquals(exception.code().id(), expectedErrorCode);
-    }
-  }
-
-}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImplTest.java
index 82715d3fe6..6a5e7fa70c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/DeploymentFlavorManagerImplTest.java
@@ -1,18 +1,12 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.verify;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.core.utilities.json.JsonUtil;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComputeDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
@@ -23,7 +17,6 @@ import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.errors.VendorSoftwareProductErrorCodes;
 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
-import org.openecomp.sdc.vendorsoftwareproduct.types.CompositionEntityResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentComputeAssociation;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityValidationData;
@@ -39,13 +32,13 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
-public class DeploymentFlavorManagerImplTest {
-
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
 
-  private static final String USER = "depFlavorTestUser";
+public class DeploymentFlavorManagerImplTest {
   private static final String VSP_ID = "VSP_ID";
-  private static final Version VERSION = new Version(0, 1);
+  private static final Version VERSION = new Version("version_id");
   private static final String COMPONENT_ID = "COMPONENT_ID";
   private static final String DF1_ID = "df1";
   private static final String DF2_ID = "df2";
@@ -55,11 +48,11 @@ public class DeploymentFlavorManagerImplTest {
   @Mock
   private VendorSoftwareProductInfoDao vspInfoDao;
   @Mock
-  DeploymentFlavorDao deploymentFlavorDaoMock;
+  private DeploymentFlavorDao deploymentFlavorDaoMock;
   @Mock
-  ComponentDao componentDaoMock;
+  private ComponentDao componentDaoMock;
   @Mock
-  ComputeDao computeDaoMock;
+  private ComputeDao computeDaoMock;
   @InjectMocks
   @Spy
   private DeploymentFlavorManagerImpl deploymentFlavorManager;
@@ -72,26 +65,26 @@ public class DeploymentFlavorManagerImplTest {
   @Test
   public void testListWhenNone() {
     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
-        deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION,  USER);
+        deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION);
     Assert.assertEquals(deploymentFlavorEntities.size(), 0);
   }
 
   @Test
   public void testCreateOnNotManual_negative() {
 
-    testCreate_negative(new DeploymentFlavorEntity(VSP_ID, VERSION,  null), USER,
+    testCreate_negative(new DeploymentFlavorEntity(VSP_ID, VERSION, null),
         VendorSoftwareProductErrorCodes.CREATE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
   }
 
   @Test
   public void testCreateManualDepFlavor() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
+    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 
     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 
-    deploymentFlavorManager.createDeploymentFlavor(expected, USER);
+    deploymentFlavorManager.createDeploymentFlavor(expected);
     verify(compositionEntityDataManagerMock).createDeploymentFlavor(expected);
   }
 
@@ -104,17 +97,16 @@ public class DeploymentFlavorManagerImplTest {
     DeploymentFlavor deploymentFlavor = expectedDiffName.getDeploymentFlavorCompositionData();
     deploymentFlavor.setModel(DF1_ID + "Name");
     expectedDiffName.setDeploymentFlavorCompositionData(deploymentFlavor);
-    List<DeploymentFlavorEntity> list = new ArrayList<DeploymentFlavorEntity>();
+    List<DeploymentFlavorEntity> list = new ArrayList<>();
     list.add(expectedDiffName);
     doReturn(list).when(deploymentFlavorDaoMock).list(anyObject());
 
     try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
+      deploymentFlavorManager.createDeploymentFlavor(expected);
       Assert.fail();
-    }
-    catch (CoreException ex) {
-      log.debug("",ex);
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_DEPLOYMENT_FLAVOR_MODEL_NOT_ALLOWED,
+    } catch (CoreException ex) {
+      Assert.assertEquals(
+          VendorSoftwareProductErrorCodes.DUPLICATE_DEPLOYMENT_FLAVOR_MODEL_NOT_ALLOWED,
           ex.code().id());
     }
   }
@@ -129,7 +121,7 @@ public class DeploymentFlavorManagerImplTest {
 
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 
-    List<String> featureGrps = new ArrayList<String>();
+    List<String> featureGrps = new ArrayList<>();
     featureGrps.add("fg1");
     featureGrps.add("fg2");
 
@@ -139,11 +131,9 @@ public class DeploymentFlavorManagerImplTest {
 
 
     try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
+      deploymentFlavorManager.createDeploymentFlavor(expected);
       Assert.fail();
-    }
-    catch (CoreException ex) {
-      log.debug("",ex);
+    } catch (CoreException ex) {
       Assert.assertEquals(VendorSoftwareProductErrorCodes.FEATURE_GROUP_NOT_EXIST_FOR_VSP,
           ex.code().id());
     }
@@ -151,13 +141,13 @@ public class DeploymentFlavorManagerImplTest {
 
   @Test
   public void testCreateManualDepFlavorWithNullCompInAssociation() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
+    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     final DeploymentFlavor deploymentFlavor =
         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
     ComponentComputeAssociation association = new ComponentComputeAssociation();
     association.setComponentId(null);
     association.setComputeFlavorId("CF1");
-    List<ComponentComputeAssociation> list = new ArrayList<ComponentComputeAssociation>();
+    List<ComponentComputeAssociation> list = new ArrayList<>();
     list.add(association);
     deploymentFlavor.setComponentComputeAssociations(list);
     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
@@ -168,26 +158,25 @@ public class DeploymentFlavorManagerImplTest {
     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 
     try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-    }
-    catch (CoreException ex) {
-      log.debug("",ex);
+      deploymentFlavorManager.createDeploymentFlavor(expected);
+    } catch (CoreException ex) {
       Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPONENT_COMPUTE_ASSOCIATION,
           ex.code().id());
-      Assert.assertEquals("Invalid request,for valid association please provide ComponentId for Compute Flavor",
+      Assert.assertEquals(
+          "Invalid request,for valid association please provide ComponentId for Compute Flavor",
           ex.getMessage());
     }
   }
 
   @Test
   public void testCreateManualDepFlavorWithInvalidComputeInAssociation() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
+    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     final DeploymentFlavor deploymentFlavor =
         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
     ComponentComputeAssociation association = new ComponentComputeAssociation();
     association.setComponentId(COMPONENT_ID);
     association.setComputeFlavorId("CF1");
-    List<ComponentComputeAssociation> list = new ArrayList<ComponentComputeAssociation>();
+    List<ComponentComputeAssociation> list = new ArrayList<>();
     list.add(association);
     deploymentFlavor.setComponentComputeAssociations(list);
     expected.setCompositionData(JsonUtil.object2Json(deploymentFlavor));
@@ -197,16 +186,14 @@ public class DeploymentFlavorManagerImplTest {
     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 
-    ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, USER);
+    ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, null);
     doReturn(component).when(componentDaoMock).get(anyObject());
 
     doReturn(null).when(computeDaoMock).get(anyObject());
 
     try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-    }
-    catch (CoreException ex) {
-      log.debug("",ex);
+      deploymentFlavorManager.createDeploymentFlavor(expected);
+    } catch (CoreException ex) {
       Assert.assertEquals(VendorSoftwareProductErrorCodes.INVALID_COMPUTE_FLAVOR_ID,
           ex.code().id());
     }
@@ -214,13 +201,13 @@ public class DeploymentFlavorManagerImplTest {
 
   @Test
   public void testCreateManualDepFlavorWithDuplicateVfcAssociation() {
-    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID);
+    DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     final DeploymentFlavor deploymentFlavor =
         JsonUtil.json2Object(expected.getCompositionData(), DeploymentFlavor.class);
     ComponentComputeAssociation association = new ComponentComputeAssociation();
     association.setComponentId(COMPONENT_ID);
     association.setComputeFlavorId("CF1");
-    List<ComponentComputeAssociation> list = new ArrayList<ComponentComputeAssociation>();
+    List<ComponentComputeAssociation> list = new ArrayList<>();
     list.add(association);
     list.add(association);
     deploymentFlavor.setComponentComputeAssociations(list);
@@ -231,18 +218,17 @@ public class DeploymentFlavorManagerImplTest {
     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 
-    ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, USER);
+    ComponentEntity component = new ComponentEntity(VSP_ID, VERSION, null);
     doReturn(component).when(componentDaoMock).get(anyObject());
 
     ComputeEntity computeEntity = new ComputeEntity(VSP_ID, VERSION, COMPONENT_ID, "CF1");
     doReturn(computeEntity).when(computeDaoMock).get(anyObject());
 
     try {
-      deploymentFlavorManager.createDeploymentFlavor(expected, USER);
-    }
-    catch (CoreException ex) {
-      log.debug("",ex);
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.SAME_VFC_ASSOCIATION_MORE_THAN_ONCE_NOT_ALLOWED,
+      deploymentFlavorManager.createDeploymentFlavor(expected);
+    } catch (CoreException ex) {
+      Assert.assertEquals(
+          VendorSoftwareProductErrorCodes.SAME_VFC_ASSOCIATION_MORE_THAN_ONCE_NOT_ALLOWED,
           ex.code().id());
     }
   }
@@ -251,30 +237,30 @@ public class DeploymentFlavorManagerImplTest {
   public void testList() {
 
     doReturn(Arrays.asList(
-        createDeploymentFlavor(VSP_ID, VERSION,  DF1_ID),
-        createDeploymentFlavor(VSP_ID, VERSION,  DF2_ID)))
+        createDeploymentFlavor(VSP_ID, VERSION, DF1_ID),
+        createDeploymentFlavor(VSP_ID, VERSION, DF2_ID)))
         .when(deploymentFlavorDaoMock).list(anyObject());
 
 
     final Collection<DeploymentFlavorEntity> deploymentFlavorEntities =
-        deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION,  USER);
+        deploymentFlavorManager.listDeploymentFlavors(VSP_ID, VERSION);
     Assert.assertEquals(deploymentFlavorEntities.size(), 2);
     for (DeploymentFlavorEntity deploymentFlavorEntity : deploymentFlavorEntities) {
       Assert.assertEquals(deploymentFlavorEntity.getDeploymentFlavorCompositionData().getModel()
-          , DF1_ID.equals(deploymentFlavorEntity.getId()) ? DF1_ID+"name" : DF2_ID+"name" );
+          , DF1_ID.equals(deploymentFlavorEntity.getId()) ? DF1_ID + "name" : DF2_ID + "name");
     }
   }
 
   @Test
   public void testUpdateHeatDepFlavor() {
-    testUpdate_negative(VSP_ID, VERSION, DF1_ID, USER,
+    testUpdate_negative(VSP_ID, VERSION, DF1_ID,
         VendorSoftwareProductErrorCodes.EDIT_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
   }
 
   @Test
   public void testUpdateNonExistingManualDepFlavorId_negative() {
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-    testUpdate_negative(VSP_ID, VERSION, DF1_ID, USER,
+    testUpdate_negative(VSP_ID, VERSION, DF1_ID,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -292,21 +278,22 @@ public class DeploymentFlavorManagerImplTest {
     VspDetails vspDetails = new VspDetails(VSP_ID, VERSION);
     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 
-    DeploymentFlavorEntity deploymentFlavorEntity = new DeploymentFlavorEntity(VSP_ID, VERSION, DF1_ID);
+    DeploymentFlavorEntity deploymentFlavorEntity =
+        new DeploymentFlavorEntity(VSP_ID, VERSION, DF1_ID);
     DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
     deploymentFlavor.setModel(DF1_ID + "_name");
     deploymentFlavor.setDescription(DF1_ID + " desc updated");
     deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
 
     CompositionEntityValidationData validationData =
-        deploymentFlavorManager.updateDeploymentFlavor(deploymentFlavorEntity, USER);
+        deploymentFlavorManager.updateDeploymentFlavor(deploymentFlavorEntity);
     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
     verify(deploymentFlavorDaoMock).update(deploymentFlavorEntity);
   }
 
   @Test
   public void testGetNonExistingDepFlavorId_negative() {
-    testGet_negative(VSP_ID, VERSION, "non existing image id", USER,
+    testGet_negative(VSP_ID, VERSION, "non existing image id",
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -320,25 +307,27 @@ public class DeploymentFlavorManagerImplTest {
     doReturn(vspDetails).when(vspInfoDao).get(anyObject());
 
     CompositionEntityResponse<DeploymentFlavor> response =
-        deploymentFlavorManager.getDeploymentFlavor(VSP_ID, VERSION, DF1_ID, USER);
+        deploymentFlavorManager.getDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     Assert.assertEquals(response.getId(), expected.getId());
-    Assert.assertEquals(response.getData().getModel(), expected.getDeploymentFlavorCompositionData().
-        getModel());
-    Assert.assertEquals(response.getData().getDescription(), expected.getDeploymentFlavorCompositionData().
-        getDescription());
+    Assert
+        .assertEquals(response.getData().getModel(), expected.getDeploymentFlavorCompositionData().
+            getModel());
+    Assert.assertEquals(response.getData().getDescription(),
+        expected.getDeploymentFlavorCompositionData().
+            getDescription());
   }
 */
   @Test
   public void testDeleteDepFlavorOnHEAT() {
     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
-    testDelete_negative(VSP_ID, VERSION,  DF1_ID, USER,
+    testDelete_negative(VSP_ID, VERSION, DF1_ID,
         VendorSoftwareProductErrorCodes.DELETE_DEPLOYMENT_FLAVOR_NOT_ALLOWED_IN_HEAT_ONBOARDING);
   }
 
   @Test
   public void testDeleteOnNotExistImage() {
-    testDelete_negative(VSP_ID, VERSION,  DF1_ID, USER,
+    testDelete_negative(VSP_ID, VERSION, DF1_ID,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -347,48 +336,35 @@ public class DeploymentFlavorManagerImplTest {
     DeploymentFlavorEntity expected = createDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     doReturn(expected).when(deploymentFlavorDaoMock).get(anyObject());
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-    deploymentFlavorManager.deleteDeploymentFlavor(VSP_ID, VERSION, DF1_ID, USER);
+    deploymentFlavorManager.deleteDeploymentFlavor(VSP_ID, VERSION, DF1_ID);
     verify(deploymentFlavorDaoMock).delete(anyObject());
   }
 
-  private void testList_negative(String vspId, Version version, String componentId, String user,
-                                 String expectedErrorCode, String expectedErrorMsg) {
-    try {
-      deploymentFlavorManager.listDeploymentFlavors(vspId, version, user);
-      Assert.fail();
-    } catch (CoreException exception) {
-      log.debug("",exception);
-      Assert.assertEquals(exception.code().id(), expectedErrorCode);
-      Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
-    }
-  }
-
-  private void testCreate_negative(DeploymentFlavorEntity deploymentFlavorEntity, String user, String
-      expectedErrorCode) {
+  private void testCreate_negative(DeploymentFlavorEntity deploymentFlavorEntity,
+                                   String expectedErrorCode) {
     try {
-      deploymentFlavorManager.createDeploymentFlavor(deploymentFlavorEntity, user);
+      deploymentFlavorManager.createDeploymentFlavor(deploymentFlavorEntity);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
   private void testDelete_negative(String vspId, Version version, String deploymentFlavorId,
-                                   String user,
                                    String expectedErrorCode) {
     try {
-      deploymentFlavorManager.deleteDeploymentFlavor(vspId, version, deploymentFlavorId, user);
+      deploymentFlavorManager.deleteDeploymentFlavor(vspId, version, deploymentFlavorId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  static DeploymentFlavorEntity createDeploymentFlavor(String vspId, Version version, String deploymentFlavorId) {
+  private static DeploymentFlavorEntity createDeploymentFlavor(String vspId, Version version,
+                                                               String deploymentFlavorId) {
 
-    DeploymentFlavorEntity deploymentFlavorEntity = new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
+    DeploymentFlavorEntity deploymentFlavorEntity =
+        new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
     DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
     deploymentFlavor.setModel(deploymentFlavorId + "name");
     deploymentFlavor.setDescription(deploymentFlavorId + " desc");
@@ -397,29 +373,28 @@ public class DeploymentFlavorManagerImplTest {
     return deploymentFlavorEntity;
   }
 
-  private void testUpdate_negative(String vspId, Version version, String
-      deploymentFlavorId, String user, String expectedErrorCode) {
+  private void testUpdate_negative(String vspId, Version version, String deploymentFlavorId,
+                                   String expectedErrorCode) {
     try {
-      DeploymentFlavorEntity deploymentFlavorEntity = new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
+      DeploymentFlavorEntity deploymentFlavorEntity =
+          new DeploymentFlavorEntity(vspId, version, deploymentFlavorId);
       DeploymentFlavor deploymentFlavor = new DeploymentFlavor();
       deploymentFlavor.setModel("Name");
       deploymentFlavorEntity.setDeploymentFlavorCompositionData(deploymentFlavor);
       deploymentFlavorManager
-          .updateDeploymentFlavor(deploymentFlavorEntity, user);
+          .updateDeploymentFlavor(new DeploymentFlavorEntity(vspId, version, deploymentFlavorId));
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
   private void testGet_negative(String vspId, Version version, String deploymentFlavorId,
-                                String user, String expectedErrorCode) {
+                                String expectedErrorCode) {
     try {
-      deploymentFlavorManager.getDeploymentFlavor(vspId, version, deploymentFlavorId, user);
+      deploymentFlavorManager.getDeploymentFlavor(vspId, version, deploymentFlavorId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImplTest.java
index 9f932b9fdf..d9b4188f5e 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ImageManagerImplTest.java
@@ -1,18 +1,11 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ImageDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ImageEntity;
@@ -29,21 +22,20 @@ import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.List;
 
-public class ImageManagerImplTest {
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
-  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+public class ImageManagerImplTest {
 
   private static final String IMAGE_NOT_EXIST_MSG =
-          "Vendor Software Product Image with Id image1 does not exist for Vendor Software Product with" +
-                  " " +
-                  "id VSP_ID and version 0.1";
+      "Vendor Software Product Image with Id image1 does not exist for Vendor Software Product with" +
+          " id VSP_ID and version 0.1";
 
-  private static final String USER = "imageTestUser";
   private static final String VSP_ID = "VSP_ID";
   private static final Version VERSION = new Version(0, 1);
   private static final String COMPONENT_ID = "COMPONENT_ID";
@@ -68,7 +60,7 @@ public class ImageManagerImplTest {
   @Test
   public void testListWhenNone() {
     final Collection<ImageEntity> imageEntities =
-            imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID, USER);
+        imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID);
     Assert.assertEquals(imageEntities.size(), 0);
   }
 
@@ -76,32 +68,32 @@ public class ImageManagerImplTest {
   public void testList() {
 
     doReturn(Arrays.asList(
-            createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID),
-            createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE2_ID)))
-            .when(imageDao).list(anyObject());
+        createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID),
+        createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE2_ID)))
+        .when(imageDao).list(anyObject());
 
 
     final Collection<ImageEntity> images =
-            imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID, USER);
+        imageManager.listImages(VSP_ID, VERSION, COMPONENT_ID);
     Assert.assertEquals(images.size(), 2);
     for (ImageEntity image : images) {
       Assert.assertEquals(image.getImageCompositionData().getFileName(),
-              IMAGE1_ID.equals(image.getId()) ? IMAGE1_ID+"_name" : IMAGE2_ID+"_name" );
+          IMAGE1_ID.equals(image.getId()) ? IMAGE1_ID + "_name" : IMAGE2_ID + "_name");
     }
   }
 
   @Test
   public void testCreateOnNotManualImage_negative() {
 
-    testCreate_negative(new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, null), USER,
-            VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
+    testCreate_negative(new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, null),
+        VendorSoftwareProductErrorCodes.ADD_IMAGE_NOT_ALLOWED_IN_HEAT_ONBOARDING);
   }
 
   @Test
   public void testCreateManualImage() {
     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-    imageManager.createImage(expected, USER);
+    imageManager.createImage(expected);
     verify(compositionEntityDataManagerMock).createImage(expected);
     verify(compositionEntityDataManagerMock).createImage(expected);
   }
@@ -115,14 +107,13 @@ public class ImageManagerImplTest {
     Image image = expectedDiffName.getImageCompositionData();
     image.setFileName(IMAGE1_ID + "_Name");
     expectedDiffName.setImageCompositionData(image);
-    List<ImageEntity> vfcImageList = new ArrayList<ImageEntity>();
+    List<ImageEntity> vfcImageList = new ArrayList<>();
     vfcImageList.add(expectedDiffName);
     doReturn(vfcImageList).when(imageDao).list(anyObject());
     try {
-      imageManager.createImage(expected, USER);
+      imageManager.createImage(expected);
       Assert.fail();
-    }
-    catch (CoreException ex) {
+    } catch (CoreException ex) {
       Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_NAME_NOT_ALLOWED,
           ex.code().id());
     }
@@ -130,18 +121,18 @@ public class ImageManagerImplTest {
 
   @Test
   public void testUpdateNonExistingImageId_negative() {
-    testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
-            VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+    testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
   @Test
   public void testUpdateImage() {
     doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID))
-            .when(imageDao).get(anyObject());
+        .when(imageDao).get(anyObject());
 
     doReturn(new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID))
-            .when(compositionEntityDataManagerMock)
-            .validateEntity(anyObject(), anyObject(), anyObject());
+        .when(compositionEntityDataManagerMock)
+        .validateEntity(anyObject(), anyObject(), anyObject());
 
     ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     Image imageData = new Image();
@@ -150,7 +141,7 @@ public class ImageManagerImplTest {
     imageEntity.setImageCompositionData(imageData);
 
     CompositionEntityValidationData validationData =
-            imageManager.updateImage(imageEntity, USER);
+        imageManager.updateImage(imageEntity);
     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
     verify(imageDao).update(imageEntity);
   }
@@ -158,16 +149,16 @@ public class ImageManagerImplTest {
   @Test
   public void testIllegalImageUpdate() {
     doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID))
-            .when(imageDao).get(anyObject());
+        .when(imageDao).get(anyObject());
 
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 
     CompositionEntityValidationData toBeReturned =
-            new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
+        new CompositionEntityValidationData(CompositionEntityType.image, IMAGE1_ID);
     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
     doReturn(toBeReturned)
-            .when(compositionEntityDataManagerMock)
-            .validateEntity(anyObject(), anyObject(), anyObject());
+        .when(compositionEntityDataManagerMock)
+        .validateEntity(anyObject(), anyObject(), anyObject());
 
     ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     Image imageData = new Image();
@@ -175,7 +166,7 @@ public class ImageManagerImplTest {
     imageData.setDescription(IMAGE1_ID + " desc updated");
     imageEntity.setImageCompositionData(imageData);
 
-    CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity, USER);
+    CompositionEntityValidationData validationData = imageManager.updateImage(imageEntity);
     Assert.assertNotNull(validationData);
     Assert.assertEquals(validationData.getErrors().size(), 2);
 
@@ -185,7 +176,7 @@ public class ImageManagerImplTest {
   @Test
   public void testUpdateHEATImageFileName() throws Exception {
     doReturn(createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID))
-            .when(imageDao).get(anyObject());
+        .when(imageDao).get(anyObject());
     ImageEntity imageEntity = new ImageEntity(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     Image imageData = new Image();
     imageData.setFileName(IMAGE1_ID + " name updated");
@@ -193,10 +184,8 @@ public class ImageManagerImplTest {
     imageEntity.setImageCompositionData(imageData);
 
     try {
-      imageManager.updateImage(imageEntity, USER);
-    }
-    catch (CoreException ex) {
-      log.debug("",ex);
+      imageManager.updateImage(imageEntity);
+    } catch (CoreException ex) {
       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
     }
 
@@ -204,8 +193,8 @@ public class ImageManagerImplTest {
 
   @Test
   public void testGetNonExistingImageId_negative() {
-    testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id", USER,
-            VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+    testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing image id",
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
   @Test
@@ -216,12 +205,12 @@ public class ImageManagerImplTest {
     doReturn(compositionSchema).when(imageManager).getImageCompositionSchema(anyObject());
 
     CompositionEntityResponse<Image> response =
-            imageManager.getImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
+        imageManager.getImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     Assert.assertEquals(response.getId(), expected.getId());
     Assert.assertEquals(response.getData().getFileName(), expected.getImageCompositionData().
-            getFileName());
+        getFileName());
     Assert.assertEquals(response.getData().getDescription(), expected.getImageCompositionData().
-            getDescription());
+        getDescription());
     Assert.assertEquals(response.getSchema(), compositionSchema);
   }
 
@@ -229,14 +218,14 @@ public class ImageManagerImplTest {
   public void testDeleteOnNotManualImage() {
     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     doReturn(expected).when(imageDao).get(anyObject());
-    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
-            VendorSoftwareProductErrorCodes.DELETE_IMAGE_NOT_ALLOWED);
+    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
+        VendorSoftwareProductErrorCodes.DELETE_IMAGE_NOT_ALLOWED);
   }
 
   @Test
   public void testDeleteOnNotExistImage() {
-    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER,
-            VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID,
+        VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
   @Test
@@ -244,7 +233,7 @@ public class ImageManagerImplTest {
     ImageEntity expected = createImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     doReturn(expected).when(imageDao).get(anyObject());
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
-    imageManager.deleteImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
+    imageManager.deleteImage(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     verify(imageDao).delete(anyObject());
   }
 
@@ -258,7 +247,7 @@ public class ImageManagerImplTest {
     doReturn(schema).when(imageManager).getImageQuestionnaireSchema(anyObject());
 
     QuestionnaireResponse questionnaire =
-            imageManager.getImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, USER);
+        imageManager.getImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID);
     Assert.assertNotNull(questionnaire);
     Assert.assertEquals(questionnaire.getData(), image.getQuestionnaireData());
     Assert.assertEquals(questionnaire.getSchema(), schema);
@@ -270,7 +259,8 @@ public class ImageManagerImplTest {
     String json = "{\"md5\" :\"FFDSD33SS\"}";
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     doReturn(new ImageEntity()).when(imageDao).get(anyObject());
-    imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json, USER);
+
+    imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
     verify(imageDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
   }
 
@@ -291,10 +281,9 @@ public class ImageManagerImplTest {
         doReturn(imageEntities).when(imageDao).list(anyObject());
         doReturn(imageEntities.get(0)).when(imageDao).getQuestionnaireData(anyObject(), anyObject(), anyObject(), anyObject());
 
-        imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json, USER);
+        imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, json);
         Assert.fail();
     } catch (CoreException exception) {
-        log.debug("",exception);
         Assert.assertEquals(exception.code().id(), VendorSoftwareProductErrorCodes.DUPLICATE_IMAGE_VERSION_NOT_ALLOWED);
 
     }
@@ -316,12 +305,9 @@ public class ImageManagerImplTest {
 
     String updJson = "{\"format\" :\"aki\"}";
     try {
-      imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson,
-          USER);
+      imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
       Assert.fail();
-    }
-    catch(CoreException ex) {
-      log.debug("",ex);
+    } catch (CoreException ex) {
       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.UPDATE_IMAGE_NOT_ALLOWED);
     }
   }
@@ -337,51 +323,34 @@ public class ImageManagerImplTest {
 
     String updJson = "{\"format\" :\"a22\"}";
     try {
-      imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson,
-              USER);
+      imageManager.updateImageQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, IMAGE1_ID, updJson);
       Assert.fail();
-    }
-    catch(CoreException ex) {
-      log.debug("",ex);
+    } catch (CoreException ex) {
       Assert.assertEquals(ex.code().id(), VendorSoftwareProductErrorCodes.VFC_IMAGE_INVALID_FORMAT);
     }
   }
 
-  private void testList_negative(String vspId, Version version, String componentId, String user,
-                                 String expectedErrorCode, String expectedErrorMsg) {
-    try {
-      imageManager.listImages(vspId, version, componentId, user);
-      Assert.fail();
-    } catch (CoreException exception) {
-      log.debug("",exception);
-      Assert.assertEquals(exception.code().id(), expectedErrorCode);
-      Assert.assertEquals(exception.getMessage(), expectedErrorMsg);
-    }
-  }
-
-  private void testCreate_negative(ImageEntity image, String user, String expectedErrorCode) {
+  private void testCreate_negative(ImageEntity image, String expectedErrorCode) {
     try {
-      imageManager.createImage(image, user);
+      imageManager.createImage(image);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
-                                   String user,
                                    String expectedErrorCode) {
     try {
-      imageManager.deleteImage(vspId, version, componentId, nicId, user);
+      imageManager.deleteImage(vspId, version, componentId, nicId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  static ImageEntity createImage(String vspId, Version version, String compId, String imageId) {
+  private static ImageEntity createImage(String vspId, Version version, String compId,
+                                         String imageId) {
     ImageEntity imageEntity = new ImageEntity(vspId, version, compId, imageId);
     Image imageData = new Image();
     imageData.setFileName(imageId + "_name");
@@ -390,21 +359,20 @@ public class ImageManagerImplTest {
     return imageEntity;
   }
 
-  private void testUpdate_negative(String vspId, Version version, String componentId, String
-          imageId, String user, String expectedErrorCode) {
+  private void testUpdate_negative(String vspId, Version version, String componentId,
+                                   String imageId, String expectedErrorCode) {
     try {
-      imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId), user);
+      imageManager.updateImage(new ImageEntity(vspId, version, componentId, imageId));
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
   private void testGet_negative(String vspId, Version version, String componentId, String imageId,
-                                String user, String expectedErrorCode) {
+                                String expectedErrorCode) {
     try {
-      imageManager.getImage(vspId, version, componentId, imageId, user);
+      imageManager.getImage(vspId, version, componentId, imageId);
       Assert.fail();
     } catch (CoreException exception) {
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java
index ecfe0e6372..2360dc7398 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java
@@ -1,57 +1,10 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.doThrow;
-import static org.openecomp.sdc.generator.util.GeneratorConstants.ALLOWED_FLAVORS_PROPERTY;
-import static org.openecomp.sdc.generator.util.GeneratorConstants.IMAGES_PROPERTY;
-import static org.openecomp.sdc.generator.util.GeneratorConstants.PORT_NODE_TEMPLATE_ID_SUFFIX;
-import static org.openecomp.sdc.tosca.services.ToscaConstants.BINDING_REQUIREMENT_ID;
-import static org.openecomp.sdc.tosca.services.ToscaConstants.COUNT_PROPERTY_NAME;
-import static org.openecomp.sdc.tosca.services.ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME;
-import static org.openecomp.sdc.tosca.services.ToscaConstants.SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME;
-import static org.openecomp.sdc.translator.services.heattotosca.Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME;
-
-import org.junit.Assert;
-import org.junit.Test;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
-import org.openecomp.sdc.generator.core.utils.GeneratorUtils;
-import org.openecomp.sdc.generator.datatypes.tosca.ComputeFlavor;
-import org.openecomp.sdc.generator.datatypes.tosca.DeploymentFlavorModel;
-import org.openecomp.sdc.generator.datatypes.tosca.LicenseFlavor;
-import org.openecomp.sdc.generator.datatypes.tosca.MultiFlavorVfcImage;
-import org.openecomp.sdc.generator.datatypes.tosca.VendorInfo;
-import org.openecomp.sdc.generator.datatypes.tosca.VspModelInfo;
-import org.openecomp.sdc.generator.util.GeneratorConstants;
-import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
-import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
-import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
-import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
-import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
-import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
-import org.openecomp.sdc.tosca.datatypes.model.NodeType;
-import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
-import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
-import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
-import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition;
-import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
-import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
-import org.openecomp.sdc.tosca.services.ToscaConstants;
-import org.openecomp.sdc.tosca.services.ToscaUtil;
-import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
 import org.openecomp.sdc.vendorsoftwareproduct.services.ManualVspDataCollectionService;
-import org.openecomp.sdc.versioning.dao.types.Version;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
 
 public class ManualVspToscaManagerImplTest {
 
@@ -96,36 +49,27 @@ public class ManualVspToscaManagerImplTest {
   private ManualVspDataCollectionService manualVspDataCollectionServiceMock;
   /*
 
-  private static List<String> supportedCapabilities = new ArrayList<>();
-  private static List<String> supportedRequirements = new ArrayList<>();
-
-  static {
-    //TODO : Read from configuration
-    supportedCapabilities.addAll(Arrays.asList("host", "os", "endpoint", "scalable"));
-    supportedRequirements.addAll(Arrays.asList("link"));
-  }
-
   @Test
   public void testGatherVspInformationInvalidVsp() {
     MockitoAnnotations.initMocks(this);
     VspModelInfo expectedVspData = new VspModelInfo();
     doThrow(new RuntimeException())
         .when(manualVspDataCollectionServiceMock)
-        .getReleaseVendor(INVALID_VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getReleaseVendor(INVALID_VSP_ID, Version.valueOf(VSP_VERSION));
     doThrow(new RuntimeException())
         .when(manualVspDataCollectionServiceMock)
-        .getAllowedFlavors(INVALID_VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getAllowedFlavors(INVALID_VSP_ID, Version.valueOf(VSP_VERSION));
     doThrow(new RuntimeException())
         .when(manualVspDataCollectionServiceMock)
-        .getVspComponentImages(INVALID_VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getVspComponentImages(INVALID_VSP_ID, Version.valueOf(VSP_VERSION));
     doThrow(new RuntimeException())
         .when(manualVspDataCollectionServiceMock)
-        .getVspComponents(INVALID_VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getVspComponents(INVALID_VSP_ID, Version.valueOf(VSP_VERSION));
     doThrow(new RuntimeException())
         .when(manualVspDataCollectionServiceMock)
-        .getVspComponentNics(INVALID_VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getVspComponentNics(INVALID_VSP_ID, Version.valueOf(VSP_VERSION));
     VspModelInfo vspModelInfo = manualVspToscaManagerMock.gatherVspInformation(INVALID_VSP_ID,
-        Version.valueOf(VSP_VERSION), USER);
+        Version.valueOf(VSP_VERSION));
     Assert.assertEquals(expectedVspData, vspModelInfo);
   }
 
@@ -138,17 +82,17 @@ public class ManualVspToscaManagerImplTest {
     Map<String, String> componentData = getComponentData();
     Map<String, List<MultiFlavorVfcImage>> vfcImageData = getVfcImageData();
     doReturn(Optional.of(RELEASE_VENDOR)).when(manualVspDataCollectionServiceMock)
-        .getReleaseVendor(VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getReleaseVendor(VSP_ID, Version.valueOf(VSP_VERSION));
     doReturn(deploymentFlavorData).when(manualVspDataCollectionServiceMock)
-        .getAllowedFlavors(VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getAllowedFlavors(VSP_ID, Version.valueOf(VSP_VERSION));
     doReturn(vfcImageData).when(manualVspDataCollectionServiceMock)
-        .getVspComponentImages(VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getVspComponentImages(VSP_ID, Version.valueOf(VSP_VERSION));
     doReturn(componentData).when(manualVspDataCollectionServiceMock)
-        .getVspComponents(VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getVspComponents(VSP_ID, Version.valueOf(VSP_VERSION));
     doReturn(componentNics).when(manualVspDataCollectionServiceMock)
-        .getVspComponentNics(VSP_ID, Version.valueOf(VSP_VERSION), USER);
+        .getVspComponentNics(VSP_ID, Version.valueOf(VSP_VERSION));
     VspModelInfo vspModelInfo = manualVspToscaManagerMock.gatherVspInformation(VSP_ID,
-        Version.valueOf(VSP_VERSION), USER);
+        Version.valueOf(VSP_VERSION));
 
     VspModelInfo expectedVspData = new VspModelInfo();
     expectedVspData.setReleaseVendor(RELEASE_VENDOR);
@@ -449,9 +393,9 @@ public class ManualVspToscaManagerImplTest {
 
   private void validateSubstitutionCapabilities(Map<String, List<String>> capabilities,
                                                 String componentName) {
-    List<String> SupportedCapabilities = supportedCapabilities;
-    Assert.assertEquals(SupportedCapabilities.size(), capabilities.size());
-    for (String capability : SupportedCapabilities) {
+    List<String> supportedCapabilities = GeneratorUtils.supportedCapabilities;
+    Assert.assertEquals(supportedCapabilities.size(), capabilities.size());
+    for (String capability : supportedCapabilities) {
       String expectedCapabilityId = capability + "_" + componentName;
       Assert.assertEquals(true, capabilities.containsKey(expectedCapabilityId));
       List<String> expectedCapabilityValue = new ArrayList<>(2);
@@ -464,10 +408,10 @@ public class ManualVspToscaManagerImplTest {
 
   private void validateSubstitutionRequirements(Map<String, List<String>> requirements,
                                                 List<Nic> nics) {
-    List<String> SupportedRequirements = supportedRequirements;
+    List<String> supportedRequirements = GeneratorUtils.supportedRequirements;
     for(Nic nic : nics) {
       String nicNodeTemplateId = nic.getName() + PORT_NODE_TEMPLATE_ID_SUFFIX;
-      for (String requirement : SupportedRequirements) {
+      for (String requirement : supportedRequirements) {
         String expectedRequirementId = requirement + "_" + nicNodeTemplateId;
         Assert.assertEquals(true, requirements.containsKey(expectedRequirementId));
         List<String> expectedRequirementValue = new ArrayList<>(2);
@@ -508,11 +452,11 @@ public class ManualVspToscaManagerImplTest {
 
     List<Map<String, RequirementDefinition>> requirements =
         deploymentFlavorNodeType.getRequirements();
-    List<String> SupportedRequirements = supportedRequirements;
+    List<String> supportedRequirements = GeneratorUtils.supportedRequirements;
     for (Nic nic : nics) {
       boolean found = false;
       String nicNodeTemplateId = nic.getName() + PORT_NODE_TEMPLATE_ID_SUFFIX;
-      for (String requirementId : SupportedRequirements) {
+      for (String requirementId : supportedRequirements) {
         String expectedRequirementId = requirementId + "_" + nicNodeTemplateId;
         for (Map<String, RequirementDefinition> requirement : requirements) {
           if (requirement.containsKey(expectedRequirementId)) {
@@ -525,8 +469,8 @@ public class ManualVspToscaManagerImplTest {
     }
 
     Map<String, CapabilityDefinition> capabilities = deploymentFlavorNodeType.getCapabilities();
-    List<String> SupportedCapabilities = supportedCapabilities;
-    for (String capabilityId : SupportedCapabilities) {
+    List<String> supportedCapabilities = GeneratorUtils.supportedCapabilities;
+    for (String capabilityId : supportedCapabilities) {
       String expectedCapabilityId = capabilityId + "_" + componentName;
       Assert.assertEquals (true, capabilities.containsKey(expectedCapabilityId));
     }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImplTest.java
index 966e1f20bf..5e735ff74e 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/MonitoringUploadsManagerImplTest.java
@@ -28,10 +28,9 @@ import static org.mockito.Mockito.verify;
 
 public class MonitoringUploadsManagerImplTest {
 
-  private static final String USER1 = "ComponentsUploadTestUser";
   private static final String COMPONENT_ID = "COMPONENT_ID";
   private static final String VSP_ID = "vspId";
-  private static final Version VERSION = new Version(0, 1);
+  private static final Version VERSION = new Version("version_id");
   private static final String TRAP_FILE_NAME = "MMSC.zip";
   private static final String POLL_FILE_NAME = "MNS OAM FW.zip";
   private static final String VES_FILE_NAME = "vesTest-yml_only.zip";
@@ -54,22 +53,19 @@ public class MonitoringUploadsManagerImplTest {
   @Test(expectedExceptions = CoreException.class)
   public void testUploadEmptyZip() {
     processFile(ZIP_DIR + EMPTY_ZIP_FILE_NAME, inputStream ->
-      monitoringUploadsManager.upload(inputStream, EMPTY_ZIP_FILE_NAME, VSP_ID, VERSION, COMPONENT_ID,
-          MonitoringUploadType.SNMP_TRAP, USER1));
+        monitoringUploadsManager
+            .upload(inputStream, EMPTY_ZIP_FILE_NAME, VSP_ID, VERSION, COMPONENT_ID,
+                MonitoringUploadType.SNMP_TRAP));
   }
 
-  @Test
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp =
+      "Monitoring file uploaded for vendor software product with Id vspId and version version_id " +
+          "is invalid: Invalid zip file")
   public void testUploadInvalidZip() {
-
-    try {
-      processFile("/notZipFile", inputStream ->
+    processFile("/notZipFile", inputStream ->
         monitoringUploadsManager
             .upload(inputStream, NOT_ZIP_FILE_NAME, VSP_ID, VERSION, COMPONENT_ID,
-                    MonitoringUploadType.VES_EVENTS, USER1));
-      Assert.fail();
-    } catch (Exception exception) {
-      Assert.assertEquals(exception.getMessage(), "Invalid zip file");
-    }
+                MonitoringUploadType.VES_EVENTS));
   }
 
   @Test
@@ -78,7 +74,7 @@ public class MonitoringUploadsManagerImplTest {
     try {
       processFile(ZIP_DIR + ZIP_WITH_FOLDERS_FILE_NAME, inputStream -> monitoringUploadsManager
           .upload(inputStream, ZIP_WITH_FOLDERS_FILE_NAME, VSP_ID, VERSION, COMPONENT_ID,
-              MonitoringUploadType.SNMP_TRAP, USER1));
+              MonitoringUploadType.SNMP_TRAP));
       Assert.fail();
     } catch (Exception exception) {
       Assert.assertEquals(exception.getMessage(), "Zip file should not contain folders");
@@ -91,7 +87,7 @@ public class MonitoringUploadsManagerImplTest {
     try {
       processFile(ZIP_DIR + INVALID_VES_FILE_NAME, inputStream -> monitoringUploadsManager
           .upload(inputStream, INVALID_VES_FILE_NAME, VSP_ID, VERSION, COMPONENT_ID,
-              MonitoringUploadType.VES_EVENTS, USER1));
+              MonitoringUploadType.VES_EVENTS));
       Assert.fail();
     } catch (Exception exception) {
       Assert.assertEquals(exception.getMessage(),
@@ -122,18 +118,18 @@ public class MonitoringUploadsManagerImplTest {
         .when(componentArtifactDaoMock).list(anyObject());
 
     MonitoringUploadStatus monitoringUploadStatus =
-        monitoringUploadsManager.listFilenames(VSP_ID, VERSION, COMPONENT_ID, USER1);
+        monitoringUploadsManager.listFilenames(VSP_ID, VERSION, COMPONENT_ID);
 
     Assert.assertEquals(monitoringUploadStatus.getSnmpTrap(), TRAP_FILE_NAME);
     Assert.assertEquals(monitoringUploadStatus.getSnmpPoll(), POLL_FILE_NAME);
     Assert.assertEquals(monitoringUploadStatus.getVesEvent(), VES_FILE_NAME);
   }
 
-  @Test (expectedExceptions = CoreException.class)
+  @Test(expectedExceptions = CoreException.class)
   public void testDeleteComponentMibWhenNone() {
     doReturn(Optional.empty()).when(componentArtifactDaoMock).getByType(any());
     monitoringUploadsManager
-        .delete(VSP_ID, VERSION, COMPONENT_ID, MonitoringUploadType.SNMP_POLL, USER1);
+        .delete(VSP_ID, VERSION, COMPONENT_ID, MonitoringUploadType.SNMP_POLL);
 
     verify(componentArtifactDaoMock, never()).delete(anyObject());
   }
@@ -146,7 +142,7 @@ public class MonitoringUploadsManagerImplTest {
             (componentArtifactDaoMock).getByType(anyObject());
 
     monitoringUploadsManager
-        .delete(VSP_ID, VERSION, COMPONENT_ID, MonitoringUploadType.SNMP_POLL, USER1);
+        .delete(VSP_ID, VERSION, COMPONENT_ID, MonitoringUploadType.SNMP_POLL);
 
     verify(componentArtifactDaoMock).delete(anyObject());
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImplTest.java
index ebdbc6af7d..54687dc80d 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NetworkManagerImplTest.java
@@ -53,10 +53,8 @@ public class NetworkManagerImplTest {
 
   private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
 
-  private static final String USER1 = "networksTestUser1";
-  private static final String USER2 = "networksTestUser2";
   private static final String VSP_ID = "vsp";
-  private static final Version VERSION = new Version(0, 1);
+  private static final Version VERSION = new Version("version_id");
   private static final String NETWORK1_ID = "network1";
   private static final String NETWORK2_ID = "network2";
 
@@ -85,7 +83,7 @@ public class NetworkManagerImplTest {
   @Test
   public void testListWhenNone() {
     Collection<NetworkEntity> networks =
-        networkManager.listNetworks(VSP_ID, null, USER1);
+        networkManager.listNetworks(VSP_ID, null);
     Assert.assertEquals(networks.size(), 0);
   }
 
@@ -96,7 +94,7 @@ public class NetworkManagerImplTest {
         createNetwork(VSP_ID, VERSION, NETWORK2_ID)))
         .when(networkDaoMock).list(anyObject());
 
-    Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, VERSION, USER1);
+    Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, VERSION);
     Assert.assertEquals(actual.size(), 2);
   }
 
@@ -113,7 +111,7 @@ public class NetworkManagerImplTest {
         expected.setNetworkCompositionData(networkData);
 
 
-        NetworkEntity created = networkManager.createNetwork(expected, USER1);
+        NetworkEntity created = networkManager.createNetwork(expected);
         Assert.assertNotNull(created);
         expected.setId(created.getId());
         expected.setVersion(VERSION01);
@@ -131,12 +129,12 @@ public class NetworkManagerImplTest {
         networkData.setName("network1 name");
         networkData.setDhcp(true);
         network.setNetworkCompositionData(networkData);
-        testCreate_negative(network, USER1, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
+        testCreate_negative(network, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
     }*/
 
   @Test
   public void testCreateOnUploadVsp_negative() {
-    testCreate_negative(new NetworkEntity(VSP_ID, VERSION, null), USER1,
+    testCreate_negative(new NetworkEntity(VSP_ID, VERSION, null),
         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
   }
 
@@ -148,7 +146,7 @@ public class NetworkManagerImplTest {
 
   @Test
   public void testUpdateNonExistingNetworkId_negative() {
-    testUpdate_negative(VSP_ID, VERSION, NETWORK1_ID, USER1,
+    testUpdate_negative(VSP_ID, VERSION, NETWORK1_ID,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -171,7 +169,7 @@ public class NetworkManagerImplTest {
     networkEntity.setNetworkCompositionData(networkData);
 
     CompositionEntityValidationData validationData =
-        networkManager.updateNetwork(networkEntity, USER1);
+        networkManager.updateNetwork(networkEntity);
     Assert.assertNotNull(validationData);
     Assert.assertEquals(validationData.getErrors().size(), 2);
 
@@ -180,7 +178,7 @@ public class NetworkManagerImplTest {
 
   @Test
   public void testGetNonExistingNetworkId_negative() {
-    testGet_negative(VSP_ID, VERSION, NETWORK1_ID, USER1,
+    testGet_negative(VSP_ID, VERSION, NETWORK1_ID,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -192,7 +190,7 @@ public class NetworkManagerImplTest {
     doReturn("schema string").when(networkManager).getCompositionSchema(anyObject());
 
     CompositionEntityResponse<Network> response =
-        networkManager.getNetwork(VSP_ID, VERSION, NETWORK1_ID, USER1);
+        networkManager.getNetwork(VSP_ID, VERSION, NETWORK1_ID);
     Assert.assertEquals(response.getId(), network.getId());
     Assert.assertEquals(response.getData(), network.getNetworkCompositionData());
     Assert.assertNotNull(response.getSchema());
@@ -206,13 +204,13 @@ public class NetworkManagerImplTest {
 
     @Test(dependsOnMethods = "testList")
     public void testDeleteNonExistingNetworkId_negative() {
-        testDelete_negative(VSP_ID, "non existing network id", USER1, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+        testDelete_negative(VSP_ID, "non existing network id", VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
     }*/
 
 /*
            @Test(dependsOnMethods = "testList")
            public void testDelete() {
-               networkManager.deleteNetwork(VSP_ID, NETWORK1_ID, USER1);
+               networkManager.deleteNetwork(VSP_ID, NETWORK1_ID);
                NetworkEntity actual = networkDaoMock.getNetwork(VSP_ID, VERSION01, NETWORK1_ID);
                Assert.assertNull(actual);
            }
@@ -224,70 +222,69 @@ public class NetworkManagerImplTest {
                NetworkEntity network3 = new NetworkEntity(VSP_ID, null, null);
                network3.setName("network3 name");
                network3.setDescription("network3 desc");
-               networkManager.createNetwork(network3, USER1);
+               networkManager.createNetwork(network3);
 
-               networkManager.deleteNetworks(VSP_ID, USER1);
+               networkManager.deleteNetworks(VSP_ID);
 
-               Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, null, USER1);
+               Collection<NetworkEntity> actual = networkManager.listNetworks(VSP_ID, null);
                Assert.assertEquals(actual.size(), 0);
            }*/
 
   @Test(dependsOnMethods = "testList")
   public void testDeleteOnUploadVsp_negative() {
-    testDelete_negative(VSP_ID, VERSION, NETWORK1_ID, USER1,
+    testDelete_negative(VSP_ID, VERSION, NETWORK1_ID,
         VendorSoftwareProductErrorCodes.VSP_COMPOSITION_EDIT_NOT_ALLOWED);
   }
 
-  private void testCreate_negative(NetworkEntity network, String user, String expectedErrorCode) {
+  private void testCreate_negative(NetworkEntity network, String expectedErrorCode) {
     try {
-      networkManager.createNetwork(network, user);
+      networkManager.createNetwork(network);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testGet_negative(String vspId, Version version, String networkId, String user,
+  private void testGet_negative(String vspId, Version version, String networkId,
                                 String expectedErrorCode) {
     try {
-      networkManager.getNetwork(vspId, version, networkId, user);
+      networkManager.getNetwork(vspId, version, networkId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testUpdate_negative(String vspId, Version version, String networkId, String user,
+  private void testUpdate_negative(String vspId, Version version, String networkId,
                                    String expectedErrorCode) {
     try {
-      networkManager.updateNetwork(new NetworkEntity(vspId, version, networkId), user);
+      networkManager.updateNetwork(new NetworkEntity(vspId, version, networkId));
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testList_negative(String vspId, Version version, String user,
-                                 String expectedErrorCode) {
+  private void testList_negative(String vspId, Version version, String expectedErrorCode) {
     try {
-      networkManager.listNetworks(vspId, version, user);
+      networkManager.listNetworks(vspId, version);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
-  private void testDelete_negative(String vspId, Version version, String networkId, String user,
+  private void testDelete_negative(String vspId, Version version, String networkId,
                                    String expectedErrorCode) {
     try {
-      networkManager.deleteNetwork(vspId, version, networkId, user);
+      networkManager.deleteNetwork(vspId, version, networkId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImplTest.java
index ba04e91c63..959b501c19 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/NicManagerImplTest.java
@@ -1,10 +1,5 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
@@ -35,17 +30,21 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
 public class NicManagerImplTest {
 
   private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
 
   private static final String NIC_NOT_EXIST_MSG =
       "Vendor Software Product NIC with Id nic1 does not exist for Vendor Software Product with " +
-          "id VSP_ID and version 0.1";
+          "id VSP_ID and version version_id";
 
-  private static final String USER = "nicTestUser";
   private static final String VSP_ID = "VSP_ID";
-  private static final Version VERSION = new Version(0, 1);
+  private static final Version VERSION = new Version("version_id");
   private static final String COMPONENT_ID = "COMPONENT_ID";
   private static final String NIC1_ID = "nic1";
   private static final String NIC2_ID = "nic2";
@@ -71,7 +70,7 @@ public class NicManagerImplTest {
 
   @Test
   public void testListWhenNone() {
-    Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID, USER);
+    Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID);
     Assert.assertEquals(nics.size(), 0);
   }
 
@@ -85,9 +84,9 @@ public class NicManagerImplTest {
     NetworkEntity network1 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK1_ID);
     NetworkEntity network2 = NetworkManagerImplTest.createNetwork(VSP_ID, VERSION, NETWORK2_ID);
     doReturn(Arrays.asList(network1, network2))
-        .when(networkManagerMock).listNetworks(VSP_ID, VERSION, USER);
+        .when(networkManagerMock).listNetworks(VSP_ID, VERSION);
 
-    Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID, USER);
+    Collection<NicEntity> nics = nicManager.listNics(VSP_ID, VERSION, COMPONENT_ID);
     Assert.assertEquals(nics.size(), 2);
     for (NicEntity nic : nics) {
       Assert.assertEquals(nic.getNicCompositionData().getNetworkName(),
@@ -103,12 +102,12 @@ public class NicManagerImplTest {
     Nic nic = nicEntity.getNicCompositionData();
     nic.setNetworkType(NetworkType.Internal);
     nicEntity.setNicCompositionData(nic);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<NicEntity> nicEntities = new ArrayList<>();
     doReturn(nicEntities).when(nicDao).list(anyObject());
     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 
-    NicEntity created = nicManager.createNic(nicEntity,USER);
+    NicEntity created = nicManager.createNic(nicEntity);
     Assert.assertNotNull(created);
   }
 
@@ -118,7 +117,7 @@ public class NicManagerImplTest {
     Nic nic = nicEntity.getNicCompositionData();
     nic.setNetworkType(NetworkType.Internal);
     nicEntity.setNicCompositionData(nic);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<NicEntity> nicEntities = new ArrayList<>();
 
     NicEntity nicEntityDiffName = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
@@ -130,11 +129,11 @@ public class NicManagerImplTest {
     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 
     try {
-      NicEntity created = nicManager.createNic(nicEntity,USER);
-    }  catch (CoreException exception) {
-      log.debug("",exception);
-            Assert.assertEquals(VendorSoftwareProductErrorCodes.NIC_NAME_FORMAT_NOT_ALLOWED,
-              exception.code().id());
+      NicEntity created = nicManager.createNic(nicEntity);
+    } catch (CoreException exception) {
+      log.debug("", exception);
+      Assert.assertEquals(VendorSoftwareProductErrorCodes.NIC_NAME_FORMAT_NOT_ALLOWED,
+          exception.code().id());
     }
   }
 
@@ -144,7 +143,7 @@ public class NicManagerImplTest {
     Nic nic = nicEntity.getNicCompositionData();
     nic.setNetworkType(NetworkType.Internal);
     nicEntity.setNicCompositionData(nic);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<NicEntity> nicEntities = new ArrayList<>();
 
     NicEntity nicEntityDiffName = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
@@ -156,11 +155,11 @@ public class NicManagerImplTest {
     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 
     try {
-      NicEntity created = nicManager.createNic(nicEntity,USER);
-    }  catch (CoreException exception) {
-      log.debug("",exception);
-      Assert.assertEquals("Invalid request, NIC with name "+ nic.getName() +
-          " already exist for component with ID "+ nicEntity.getComponentId() +".",
+      NicEntity created = nicManager.createNic(nicEntity);
+    } catch (CoreException exception) {
+      log.debug("", exception);
+      Assert.assertEquals("Invalid request, NIC with name " + nic.getName() +
+              " already exist for component with ID " + nicEntity.getComponentId() + ".",
           exception.code().message());
       Assert.assertEquals(VendorSoftwareProductErrorCodes.DUPLICATE_NIC_NAME_NOT_ALLOWED,
           exception.code().id());
@@ -173,19 +172,20 @@ public class NicManagerImplTest {
     Nic nic = nicEntity.getNicCompositionData();
     nic.setNetworkType(NetworkType.External);
     nicEntity.setNicCompositionData(nic);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<NicEntity> nicEntities = new ArrayList<>();
     doReturn(nicEntities).when(nicDao).list(anyObject());
     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 
     try {
-      NicEntity created = nicManager.createNic(nicEntity,USER);
-    }  catch (CoreException exception) {
-      log.debug("",exception);
+      NicEntity created = nicManager.createNic(nicEntity);
+    } catch (CoreException exception) {
+      log.debug("", exception);
       Assert.assertEquals("Invalid request,NetworkId not allowed for External Networks",
           exception.code().message());
-      Assert.assertEquals(VendorSoftwareProductErrorCodes.NETWORKID_NOT_ALLOWED_FOR_EXTERNAL_NETWORK,
-          exception.code().id());
+      Assert
+          .assertEquals(VendorSoftwareProductErrorCodes.NETWORKID_NOT_ALLOWED_FOR_EXTERNAL_NETWORK,
+              exception.code().id());
     }
   }
 
@@ -196,29 +196,29 @@ public class NicManagerImplTest {
     nic.setNetworkType(NetworkType.Internal);
     nic.setNetworkDescription(NIC1_ID);
     nicEntity.setNicCompositionData(nic);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     Collection<NicEntity> nicEntities = new ArrayList<>();
     doReturn(nicEntities).when(nicDao).list(anyObject());
     doReturn(nicEntity).when(compositionEntityDataManagerMock).createNic(anyObject());
 
     try {
-      NicEntity created = nicManager.createNic(nicEntity,USER);
-    }  catch (CoreException exception) {
-      log.debug("",exception);
+      NicEntity created = nicManager.createNic(nicEntity);
+    } catch (CoreException exception) {
+      log.debug("", exception);
       Assert.assertEquals("Invalid request, Network Description not allowed for Internal Networks",
           exception.code().message());
       Assert.assertEquals(VendorSoftwareProductErrorCodes
-          .NETWORK_DESCRIPTION_NOT_ALLOWED_FOR_INTERNAL_NETWORK,exception.code().id());
+          .NETWORK_DESCRIPTION_NOT_ALLOWED_FOR_INTERNAL_NETWORK, exception.code().id());
     }
   }
 
   @Test
   public void testDeleteNic() {
     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
-    doReturn(true).when(vspInfoDao).isManual(anyObject(),anyObject());
+    doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
     doReturn(nicEntity).when(nicDao).get(anyObject());
 
-    nicManager.deleteNic(VSP_ID,new Version(0,1),COMPONENT_ID,NIC1_ID,USER);
+    nicManager.deleteNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
 
   }
 
@@ -227,9 +227,12 @@ public class NicManagerImplTest {
     NicEntity nicEntity = createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID);
 
     doReturn(nicEntity).when(nicDao).get(anyObject());
+    doReturn("{}").when(nicManager).getNicCompositionSchema(anyObject());
 
-    nicManager.updateNicQuestionnaire(VSP_ID,new Version(0,1),COMPONENT_ID,NIC1_ID,"Ques",USER);
+    nicManager
+        .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "Ques");
 
+    verify(nicDao).updateQuestionnaireData(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "Ques");
   }
 
 //    @Test(dependsOnMethods = "testListWhenNone")
@@ -243,7 +246,7 @@ public class NicManagerImplTest {
         Nic nicData = new Nic();
         nicData.setName("nic1 name");
         nic.setNicCompositionData(nicData);
-        testCreate_negative(nic, USER, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
+        testCreate_negative(nic, UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
     }*/
 
 //    @Test(dependsOnMethods = {"testCreate"})
@@ -254,7 +257,7 @@ public class NicManagerImplTest {
 //        compData12.setDescription("comp12 desc");
 //        component12.setComponentCompositionData(compData12);
 //
-//        String component12Id = nicManager.createComponent(component12, USER).getId();
+//        String component12Id = nicManager.createComponent(component12).getId();
 //        testCreate(VSP_ID, component12Id, NETWORK1_ID, NETWORK1_ID.getNetworkCompositionData().getName());
 //    }
 
@@ -266,7 +269,7 @@ public class NicManagerImplTest {
   @Test
   public void testCreateOnUploadVsp_negative() {
 
-    testCreate_negative(new NicEntity(VSP_ID, VERSION, COMPONENT_ID, null), USER,
+    testCreate_negative(new NicEntity(VSP_ID, VERSION, COMPONENT_ID, null),
         VendorSoftwareProductErrorCodes.ADD_NIC_NOT_ALLOWED_IN_HEAT_ONBOARDING);
   }
 
@@ -274,7 +277,7 @@ public class NicManagerImplTest {
   public void testUpdateNonExistingNicId_negative() {
     doReturn(null).when(nicDao).get(anyObject());
 
-    testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER,
+    testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -295,7 +298,7 @@ public class NicManagerImplTest {
     nicEntity.setNicCompositionData(nicData);
 
     CompositionEntityValidationData validationData =
-        nicManager.updateNic(nicEntity, USER);
+        nicManager.updateNic(nicEntity);
     Assert.assertTrue(validationData == null || validationData.getErrors() == null);
     verify(nicDao).update(nicEntity);
   }
@@ -319,7 +322,7 @@ public class NicManagerImplTest {
     nicData.setNetworkId(NETWORK1_ID);
     nicEntity.setNicCompositionData(nicData);
 
-    CompositionEntityValidationData validationData = nicManager.updateNic(nicEntity, USER);
+    CompositionEntityValidationData validationData = nicManager.updateNic(nicEntity);
     Assert.assertNotNull(validationData);
     Assert.assertEquals(validationData.getErrors().size(), 2);
 
@@ -329,14 +332,14 @@ public class NicManagerImplTest {
   @Test
   public void testUpdateIncorrectNameFormat() {
     doReturn(createNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, NETWORK1_ID))
-            .when(nicDao).get(anyObject());
+        .when(nicDao).get(anyObject());
 
     CompositionEntityValidationData toBeReturned =
-            new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
+        new CompositionEntityValidationData(CompositionEntityType.nic, NIC1_ID);
     toBeReturned.setErrors(Arrays.asList("error1", "error2"));
     doReturn(toBeReturned)
-            .when(compositionEntityDataManagerMock)
-            .validateEntity(anyObject(), anyObject(), anyObject());
+        .when(compositionEntityDataManagerMock)
+        .validateEntity(anyObject(), anyObject(), anyObject());
     doReturn(true).when(vspInfoDao).isManual(anyObject(), anyObject());
 
     NicEntity nicEntity = new NicEntity(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
@@ -347,20 +350,19 @@ public class NicManagerImplTest {
     nicEntity.setNicCompositionData(nicData);
 
     try {
-      nicManager.updateNic(nicEntity, USER);
+      nicManager.updateNic(nicEntity);
       Assert.fail();
-    }
-    catch (CoreException ex) {
-      log.debug("",ex);
+    } catch (CoreException ex) {
+      log.debug("", ex);
       Assert.assertEquals(VendorSoftwareProductErrorCodes.NIC_NAME_FORMAT_NOT_ALLOWED,
-              ex.code().id());
+          ex.code().id());
     }
   }
 
 
   @Test
   public void testGetNonExistingNicId_negative() {
-    testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing nic id", USER,
+    testGet_negative(VSP_ID, VERSION, COMPONENT_ID, "non existing nic id",
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
   }
 
@@ -373,7 +375,7 @@ public class NicManagerImplTest {
     doReturn(compositionSchema).when(nicManager).getNicCompositionSchema(anyObject());
 
     CompositionEntityResponse<Nic> response =
-        nicManager.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
+        nicManager.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
     Assert.assertEquals(response.getId(), expected.getId());
     Assert.assertEquals(response.getData(), expected.getNicCompositionData());
     Assert.assertEquals(response.getSchema(), compositionSchema);
@@ -387,32 +389,32 @@ public class NicManagerImplTest {
 
     @Test
     public void testDeleteNonExistingNicId_negative() {
-        testDelete_negative(VSP_ID, COMPONENT_ID, "non existing nic id", USER, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+        testDelete_negative(VSP_ID, COMPONENT_ID, "non existing nic id", VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
     }
 
     @Test(dependsOnMethods = "testList")
     public void testDeleteNonExistingComponentId_negative() {
-        testDelete_negative(VSP_ID, "non existing component id", NIC1_ID, USER, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+        testDelete_negative(VSP_ID, "non existing component id", NIC1_ID, VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
     }*/
 
 /*
     @Test(dependsOnMethods = "testList")
     public void testDelete() {
-        nicManager.deleteNic(VSP_ID, COMPONENT_ID, NIC1_ID, USER);
+        nicManager.deleteNic(VSP_ID, COMPONENT_ID, NIC1_ID);
         NicEntity actual = vendorSoftwareProductDao.getNic(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
         Assert.assertNull(actual);
     }*/
 
   @Test
   public void testDeleteOnUploadVsp_negative() {
-    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER,
+    testDelete_negative(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID,
         VendorSoftwareProductErrorCodes.DELETE_NIC_NOT_ALLOWED);
   }
 
   @Test(expectedExceptions = CoreException.class,
       expectedExceptionsMessageRegExp = NIC_NOT_EXIST_MSG)
   public void testGetNonExistingNicQuestionnaire() throws Exception {
-    nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
+    nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
   }
 
   @Test
@@ -425,7 +427,7 @@ public class NicManagerImplTest {
     doReturn(schema).when(nicManager).getNicQuestionnaireSchema(anyObject());
 
     QuestionnaireResponse questionnaire =
-        nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, USER);
+        nicManager.getNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID);
     Assert.assertNotNull(questionnaire);
     Assert.assertEquals(questionnaire.getData(), nic.getQuestionnaireData());
     Assert.assertEquals(questionnaire.getSchema(), schema);
@@ -437,7 +439,7 @@ public class NicManagerImplTest {
   public void testUpdateNonExistingNicQuestionnaire() throws Exception {
     doReturn(null).when(nicDao).get(anyObject());
     nicManager
-        .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "questionnaire data", USER);
+        .updateNicQuestionnaire(VSP_ID, VERSION, COMPONENT_ID, NIC1_ID, "questionnaire data");
   }
 
   @Test
@@ -445,46 +447,45 @@ public class NicManagerImplTest {
 
   }
 
-  private void testCreate_negative(NicEntity nic, String user, String expectedErrorCode) {
+  private void testCreate_negative(NicEntity nic, String expectedErrorCode) {
     try {
-      nicManager.createNic(nic, user);
+      nicManager.createNic(nic);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
   private void testGet_negative(String vspId, Version version, String componentId, String nicId,
-                                String user, String expectedErrorCode) {
+                                String expectedErrorCode) {
     try {
-      nicManager.getNic(vspId, version, componentId, nicId, user);
+      nicManager.getNic(vspId, version, componentId, nicId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
   private void testUpdate_negative(String vspId, Version version, String componentId, String nicId,
-                                   String user, String expectedErrorCode) {
+                                   String expectedErrorCode) {
     try {
-      nicManager.updateNic(new NicEntity(vspId, version, componentId, nicId), user);
+      nicManager.updateNic(new NicEntity(vspId, version, componentId, nicId));
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
 
   private void testDelete_negative(String vspId, Version version, String componentId, String nicId,
-                                   String user,
                                    String expectedErrorCode) {
     try {
-      nicManager.deleteNic(vspId, version, componentId, nicId, user);
+      nicManager.deleteNic(vspId, version, componentId, nicId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImplTest.java
index d1cba65182..26ec917546 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateCandidateManagerImplTest.java
@@ -1,18 +1,14 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doReturn;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.openecomp.core.utilities.file.FileUtils;
 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.ComponentDependencyModelDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentDependencyModelEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
@@ -37,10 +33,13 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.Optional;
 
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+
 public class OrchestrationTemplateCandidateManagerImplTest {
-  private static final String USER1 = "vspTestUser1";
   private static final String VSP_ID = "vspId";
-  private static final Version VERSION01 = new Version(0, 1);
+  private static final Version VERSION01 = new Version("versionId");
 
   private static final String COMPONENT_ORIG_ID_1 = "Component_Pd_Server_Id_Orig";
   private static final String COMPONENT_ORIG_ID_2 = "Component_Sm_Server_Id_Orig";
@@ -58,8 +57,6 @@ public class OrchestrationTemplateCandidateManagerImplTest {
   private static final String COMPONENT_NAME_4 = "ps_server";
 
   @Mock
-  private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
-  @Mock
   private VendorSoftwareProductInfoDao vspInfoDaoMock;
   @Mock
   private CandidateService candidateServiceMock;
@@ -67,6 +64,8 @@ public class OrchestrationTemplateCandidateManagerImplTest {
   private OrchestrationTemplateDao orchestrationTemplateDaoMock;
   @Mock
   private ComponentDependencyModelDao componentDependencyModelDaoMock;
+  @Mock
+  private ComponentDao componentDaoMock;
 
   @InjectMocks
   private OrchestrationTemplateCandidateManagerImpl candidateManager;
@@ -100,7 +99,7 @@ public class OrchestrationTemplateCandidateManagerImplTest {
     doReturn(new VspDetails(VSP_ID, VERSION01))
         .when(vspInfoDaoMock).get(anyObject());
     doReturn(null)
-        .when(orchestrationTemplateDaoMock).getValidationData(anyObject(), anyObject());
+        .when(orchestrationTemplateDaoMock).getInfo(anyObject(), anyObject());
 
     doReturn("{}").when(candidateServiceMock).createManifest(anyObject(), anyObject());
     doReturn(Optional.empty()).when(candidateServiceMock)
@@ -109,7 +108,7 @@ public class OrchestrationTemplateCandidateManagerImplTest {
 
 
     OrchestrationTemplateActionResponse response =
-        candidateManager.process(VSP_ID, VERSION01, USER1);
+        candidateManager.process(VSP_ID, VERSION01);
 
     Assert.assertNotNull(response);
   }
@@ -118,12 +117,11 @@ public class OrchestrationTemplateCandidateManagerImplTest {
   public void testUpdateVspComponentDependenciesHeatReuploadMoreComponents() {
     Collection<ComponentDependencyModelEntity> existingComponentsDependencies =
         getExistingComponentDependencies();
-    doReturn(existingComponentsDependencies).
-        when(vendorSoftwareProductDaoMock).listComponentDependencies(anyObject(), anyObject());
+    doReturn(existingComponentsDependencies).when(componentDependencyModelDaoMock)
+        .list(anyObject());
     Collection<ComponentEntity> componentListWithMoreComponentsInHeat =
         getComponentListWithMoreComponentsInHeat();
-    doReturn(componentListWithMoreComponentsInHeat).when(vendorSoftwareProductDaoMock)
-        .listComponents(anyObject(), anyObject());
+    doReturn(componentListWithMoreComponentsInHeat).when(componentDaoMock).list(anyObject());
     Map<String, String> componentIdNameInfoBeforeProcess = getVspInitComponentIdNameInfo();
     orchestrationUtil.updateVspComponentDependencies(anyObject(), anyObject(),
         componentIdNameInfoBeforeProcess);
@@ -136,14 +134,14 @@ public class OrchestrationTemplateCandidateManagerImplTest {
     Collection<ComponentDependencyModelEntity> existingComponentsDependencies =
         getExistingComponentDependencies();
     doReturn(existingComponentsDependencies).
-        when(vendorSoftwareProductDaoMock).listComponentDependencies(anyObject(), anyObject());
+        when(componentDependencyModelDaoMock).list(anyObject());
     Collection<ComponentEntity> componentListWithLessComponentsInHeat =
         getComponentListWithLessComponentsInHeat();
-    doReturn(componentListWithLessComponentsInHeat).when(vendorSoftwareProductDaoMock)
-        .listComponents(anyObject(), anyObject());
+    doReturn(componentListWithLessComponentsInHeat).when(componentDaoMock).list(anyObject());
     Map<String, String> componentIdNameInfoBeforeProcess = getVspInitComponentIdNameInfo();
-    orchestrationUtil.updateVspComponentDependencies(anyObject(), anyObject(),
-        componentIdNameInfoBeforeProcess);
+    orchestrationUtil
+        .updateVspComponentDependencies(anyObject(), anyObject(),
+            componentIdNameInfoBeforeProcess);
     Mockito.verify(componentDependencyModelDaoMock, Mockito.times(1)).update(anyObject());
     Mockito.verify(componentDependencyModelDaoMock, Mockito.times(1)).delete(anyObject());
   }
@@ -152,12 +150,11 @@ public class OrchestrationTemplateCandidateManagerImplTest {
   public void testUpdateVspComponentDependenciesHeatReuploadSameComponents() {
     Collection<ComponentDependencyModelEntity> existingComponentsDependencies =
         getExistingComponentDependencies();
-    doReturn(existingComponentsDependencies).
-        when(vendorSoftwareProductDaoMock).listComponentDependencies(anyObject(), anyObject());
+    doReturn(existingComponentsDependencies).when(componentDependencyModelDaoMock)
+        .list(anyObject());
     Collection<ComponentEntity> componentListWithSameComponentsInHeat =
         getComponentListWithSameComponentsInHeat();
-    doReturn(componentListWithSameComponentsInHeat).when(vendorSoftwareProductDaoMock)
-        .listComponents(anyObject(), anyObject());
+    doReturn(componentListWithSameComponentsInHeat).when(componentDaoMock).list(anyObject());
     Map<String, String> componentIdNameInfoBeforeProcess = getVspInitComponentIdNameInfo();
     orchestrationUtil.updateVspComponentDependencies(anyObject(), anyObject(),
         componentIdNameInfoBeforeProcess);
@@ -169,12 +166,11 @@ public class OrchestrationTemplateCandidateManagerImplTest {
   public void testUpdateVspComponentDependenciesHeatReuploadNoComponents() {
     Collection<ComponentDependencyModelEntity> existingComponentsDependencies =
         getExistingComponentDependencies();
-    doReturn(existingComponentsDependencies).
-        when(vendorSoftwareProductDaoMock).listComponentDependencies(anyObject(), anyObject());
+    doReturn(existingComponentsDependencies).when(componentDependencyModelDaoMock)
+        .list(anyObject());
     Collection<ComponentEntity> componentListWithMoreComponentsInHeat =
         new ArrayList<>();
-    doReturn(componentListWithMoreComponentsInHeat).when(vendorSoftwareProductDaoMock)
-        .listComponents(anyObject(), anyObject());
+    doReturn(componentListWithMoreComponentsInHeat).when(componentDaoMock).list(anyObject());
     Map<String, String> componentIdNameInfoBeforeProcess = getVspInitComponentIdNameInfo();
     orchestrationUtil.updateVspComponentDependencies(anyObject(), anyObject(),
         componentIdNameInfoBeforeProcess);
@@ -193,8 +189,7 @@ public class OrchestrationTemplateCandidateManagerImplTest {
   @Test
   public void testVspComponentIdNameInfo() {
     Collection<ComponentEntity> initialVspComponents = getInitialVspComponents();
-    doReturn(initialVspComponents).when(vendorSoftwareProductDaoMock)
-        .listComponents(anyObject(), anyObject());
+    doReturn(initialVspComponents).when(componentDaoMock).list(anyObject());
     Map<String, String> vspComponentIdNameInfo =
         orchestrationUtil.getVspComponentIdNameInfo(anyObject(), anyObject());
     Assert.assertEquals(vspComponentIdNameInfo.size(), 3);
@@ -210,8 +205,7 @@ public class OrchestrationTemplateCandidateManagerImplTest {
     componentEntity.setId(COMPONENT_ORIG_ID_4);
     initialVspComponents.add(componentEntity);
 
-    doReturn(initialVspComponents).when(vendorSoftwareProductDaoMock)
-        .listComponents(anyObject(), anyObject());
+    doReturn(initialVspComponents).when(componentDaoMock).list(anyObject());
     Map<String, String> vspComponentIdNameInfo =
         orchestrationUtil.getVspComponentIdNameInfo(anyObject(), anyObject());
     Assert.assertEquals(vspComponentIdNameInfo.size(), 3);
@@ -250,7 +244,7 @@ public class OrchestrationTemplateCandidateManagerImplTest {
 
   private Collection<ComponentEntity> getComponentListWithLessComponentsInHeat() {
     Collection<ComponentEntity> vspComponents = getInitialVspComponents();
-    for (Iterator<ComponentEntity> iterator = vspComponents.iterator(); iterator.hasNext();) {
+    for (Iterator<ComponentEntity> iterator = vspComponents.iterator(); iterator.hasNext(); ) {
       ComponentEntity componentEntity = iterator.next();
       if (componentEntity.getComponentCompositionData().getName().equals(COMPONENT_NAME_1)) {
         iterator.remove();
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateProcessCsarHandlerTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateProcessCsarHandlerTest.java
index c2a207d6d9..bc3727381b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateProcessCsarHandlerTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/OrchestrationTemplateProcessCsarHandlerTest.java
@@ -6,14 +6,12 @@ import org.openecomp.core.enrichment.factory.EnrichmentManagerFactory;
 import org.openecomp.core.factory.impl.AbstractFactoryBase;
 import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDaoFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateCandidateData;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.factory.CandidateServiceFactory;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.mock.CandidateServiceFactoryMock;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.mock.NoSqlDbFactoryMock;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.mock.PackageInfoDaoFactoryImplMock;
-import org.openecomp.sdc.vendorsoftwareproduct.impl.mock.VendorSoftwareProductDaoFactoryMock;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.process.OrchestrationTemplateProcessCsarHandler;
 import org.openecomp.sdc.vendorsoftwareproduct.types.OrchestrationTemplateActionResponse;
 import org.openecomp.sdc.versioning.dao.types.Version;
@@ -21,27 +19,31 @@ import org.openecomp.sdc.versioning.dao.types.Version;
 import java.nio.ByteBuffer;
 
 import static org.junit.Assert.assertFalse;
-public class OrchestrationTemplateProcessCsarHandlerTest {
-
-
-    @Before
-    public void insertMocks(){
-        EnrichmentManagerFactory.getInstance();
-        AbstractFactoryBase.registerFactory(NoSqlDbFactory.class, NoSqlDbFactoryMock.class);
-        AbstractFactoryBase.registerFactory(PackageInfoDaoFactory.class, PackageInfoDaoFactoryImplMock.class);
-        AbstractFactoryBase.registerFactory(PackageInfoDaoFactory.class, PackageInfoDaoFactoryImplMock.class);
-        AbstractFactoryBase.registerFactory(VendorSoftwareProductDaoFactory.class, VendorSoftwareProductDaoFactoryMock.class);
-        AbstractFactoryBase.registerFactory(CandidateServiceFactory.class, CandidateServiceFactoryMock.class);
-    }
 
+public class OrchestrationTemplateProcessCsarHandlerTest {
 
 
-    @Test
-    public void validateErrorHandling(){
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        OrchestrationTemplateCandidateData orchestrationTemplateCandidateData = new OrchestrationTemplateCandidateData(ByteBuffer.wrap("".getBytes()),"");
-        OrchestrationTemplateProcessCsarHandler handler = new OrchestrationTemplateProcessCsarHandler();
-        OrchestrationTemplateActionResponse response = handler.process(vspDetails, orchestrationTemplateCandidateData, "007");
-        assertFalse(response.getErrors().isEmpty());
-    }
+  @Before
+  public void insertMocks() {
+    EnrichmentManagerFactory.getInstance();
+    AbstractFactoryBase.registerFactory(NoSqlDbFactory.class, NoSqlDbFactoryMock.class);
+    AbstractFactoryBase
+        .registerFactory(PackageInfoDaoFactory.class, PackageInfoDaoFactoryImplMock.class);
+    AbstractFactoryBase
+        .registerFactory(PackageInfoDaoFactory.class, PackageInfoDaoFactoryImplMock.class);
+    AbstractFactoryBase
+        .registerFactory(CandidateServiceFactory.class, CandidateServiceFactoryMock.class);
+  }
+
+
+  @Test
+  public void validateErrorHandling() {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    OrchestrationTemplateCandidateData orchestrationTemplateCandidateData =
+        new OrchestrationTemplateCandidateData(ByteBuffer.wrap("".getBytes()), "", "zip", "file");
+    OrchestrationTemplateProcessCsarHandler handler = new OrchestrationTemplateProcessCsarHandler();
+    OrchestrationTemplateActionResponse response =
+        handler.process(vspDetails, orchestrationTemplateCandidateData);
+    assertFalse(response.getErrors().isEmpty());
+  }
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java
index 478bdfbbba..b925ab9270 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ProcessManagerImplTest.java
@@ -1,19 +1,18 @@
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.logging.api.Logger;
 import org.openecomp.sdc.logging.api.LoggerFactory;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.ProcessDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessType;
 import org.openecomp.sdc.versioning.dao.types.Version;
@@ -28,12 +27,13 @@ import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.Collection;
 
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Matchers.eq;
 
 public class ProcessManagerImplTest {
 
@@ -48,9 +48,7 @@ public class ProcessManagerImplTest {
   private static final String ARTIFACT_NAME = "artifact.sh";
 
   @Mock
-  private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
-  @Mock
-  private ActivityLogManager activityLogManagerMock;
+  private ProcessDao processDaoMock;
 
   @InjectMocks
   @Spy
@@ -66,7 +64,7 @@ public class ProcessManagerImplTest {
   @Test
   public void testListWhenNone() {
     Collection<ProcessEntity> processes =
-        processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
+        processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID);
     Assert.assertEquals(processes.size(), 0);
   }
 
@@ -75,17 +73,17 @@ public class ProcessManagerImplTest {
     doReturn(Arrays.asList(
         createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID),
         createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID)))
-        .when(vendorSoftwareProductDaoMock).listProcesses(VSP_ID, VERSION, COMPONENT_ID);
+        .when(processDaoMock).list(any(ProcessEntity.class));
 
     Collection<ProcessEntity> actual =
-        processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
+        processManager.listProcesses(VSP_ID, VERSION, COMPONENT_ID);
     Assert.assertEquals(actual.size(), 2);
   }
 
   @Test
   public void testDeleteListWhenNone() {
-    processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
-    verify(vendorSoftwareProductDaoMock, never()).deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
+    processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
+    verify(processDaoMock, never()).delete(any(ProcessEntity.class));
   }
 
   @Test
@@ -93,15 +91,15 @@ public class ProcessManagerImplTest {
     ProcessEntity process1 = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     ProcessEntity process2 = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS2_ID);
     doReturn(Arrays.asList(process1, process2))
-        .when(vendorSoftwareProductDaoMock).listProcesses(VSP_ID, VERSION, COMPONENT_ID);
+        .when(processDaoMock).list(any(ProcessEntity.class));
     doNothing().when(processManager)
         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process1.getName());
     doNothing().when(processManager)
         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process2.getName());
 
-    processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID, USER1);
+    processManager.deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
 
-    verify(vendorSoftwareProductDaoMock).deleteProcesses(VSP_ID, VERSION, COMPONENT_ID);
+    verify(processDaoMock).deleteAll(eq(new ProcessEntity(VSP_ID, VERSION, COMPONENT_ID, null)));
     verify(processManager)
         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, process1.getName());
     verify(processManager)
@@ -118,7 +116,7 @@ public class ProcessManagerImplTest {
     doNothing().when(processManager)
         .createUniqueName(VSP_ID, VERSION, COMPONENT_ID, processToCreate.getName());
 
-    ProcessEntity process = processManager.createProcess(processToCreate, USER1);
+    ProcessEntity process = processManager.createProcess(processToCreate);
     Assert.assertNotNull(process);
     process.setId(process.getId());
 
@@ -134,13 +132,12 @@ public class ProcessManagerImplTest {
         new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
         .when(processManager).validateUniqueName(VSP_ID, VERSION, COMPONENT_ID, process.getName());
 
-    processManager.createProcess(process, USER1);
+    processManager.createProcess(process);
   }
 
   @Test
   public void testUpdateNonExistingProcessId_negative() {
-    doReturn(null).when(vendorSoftwareProductDaoMock)
-        .getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(null).when(processDaoMock).get(any(ProcessEntity.class));
 
     testUpdate_negative(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1,
         VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
@@ -149,8 +146,7 @@ public class ProcessManagerImplTest {
   @Test(expectedExceptions = CoreException.class)
   public void testUpdateWithExistingName_negative() {
     ProcessEntity existingProcess = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
-    doReturn(existingProcess).when
-        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(existingProcess).when(processDaoMock).get(any(ProcessEntity.class));
 
     ProcessEntity processToUpdate = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     doThrow(new CoreException(
@@ -159,22 +155,21 @@ public class ProcessManagerImplTest {
         .updateUniqueName(VSP_ID, VERSION, COMPONENT_ID, existingProcess.getName(),
             processToUpdate.getName());
 
-    processManager.updateProcess(processToUpdate, USER1);
+    processManager.updateProcess(processToUpdate);
   }
 
   @Test
   public void testUpdate() {
     ProcessEntity existingProcess = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
-    doReturn(existingProcess).when
-        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(existingProcess).when(processDaoMock).get(any(ProcessEntity.class));
 
     ProcessEntity processToUpdate = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     doNothing().when(processManager)
         .updateUniqueName(VSP_ID, VERSION, COMPONENT_ID, existingProcess.getName(),
             processToUpdate.getName());
 
-    processManager.updateProcess(processToUpdate, USER1);
-    verify(vendorSoftwareProductDaoMock).updateProcess(processToUpdate);
+    processManager.updateProcess(processToUpdate);
+    verify(processDaoMock).update(processToUpdate);
   }
 
 
@@ -187,10 +182,9 @@ public class ProcessManagerImplTest {
   @Test
   public void testGet() {
     ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
-    doReturn(process).when
-        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(process).when(processDaoMock).get(any(ProcessEntity.class));
     ProcessEntity actual =
-        processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+        processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     Assert.assertEquals(actual, process);
     Assert.assertNull(actual.getArtifactName());
   }
@@ -199,29 +193,28 @@ public class ProcessManagerImplTest {
   public void testGetAfterUploadArtifact() {
     ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     process.setArtifactName(ARTIFACT_NAME);
-    doReturn(process).when
-        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(process).when(processDaoMock).get(any(ProcessEntity.class));
     ProcessEntity actual =
-        processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+        processManager.getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     Assert.assertEquals(actual, process);
     Assert.assertEquals(actual.getArtifactName(), ARTIFACT_NAME);
   }
 
   @Test(expectedExceptions = CoreException.class)
   public void testDeleteNonExistingProcessId_negative() {
-    processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+    processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
   }
 
   @Test
   public void testDelete() {
     ProcessEntity processToDelete = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
-    doReturn(processToDelete).when
-        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(processToDelete).when(processDaoMock)
+        .get(any(ProcessEntity.class));
     doNothing().when(processManager).deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID,
         processToDelete.getName());
 
-    processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
-    verify(vendorSoftwareProductDaoMock).deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    processManager.deleteProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    verify(processDaoMock).delete(any(ProcessEntity.class));
     verify(processManager)
         .deleteUniqueValue(VSP_ID, VERSION, COMPONENT_ID, processToDelete.getName());
   }
@@ -235,21 +228,13 @@ public class ProcessManagerImplTest {
   @Test
   public void testUploadArtifact() {
     ProcessEntity process = createProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
-    doReturn(process).when
-        (vendorSoftwareProductDaoMock).getProcess(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(process).when(processDaoMock).get(any(ProcessEntity.class));
 
     byte[] artifactBytes = "bla bla".getBytes();
     processManager
         .uploadProcessArtifact(new ByteArrayInputStream(artifactBytes), ARTIFACT_NAME,
-            VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
-    verify(vendorSoftwareProductDaoMock)
-        .uploadProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, artifactBytes,
-            ARTIFACT_NAME);
-
-    verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION.getMajor()+1));
-    Assert.assertTrue(activityLogEntity.isSuccess());
+            VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    verify(processDaoMock).uploadArtifact(any(ProcessEntity.class));
   }
 
   @Test
@@ -269,11 +254,11 @@ public class ProcessManagerImplTest {
     ProcessEntity processArtifact =
         new ProcessEntity(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     processArtifact.setArtifact(ByteBuffer.wrap("bla bla".getBytes()));
-    doReturn(processArtifact).when(vendorSoftwareProductDaoMock)
-        .getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(processArtifact).when(processDaoMock)
+        .getArtifact(any(ProcessEntity.class));
 
     File actual =
-        processManager.getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
+        processManager.getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     Assert.assertNotNull(actual);
   }
 
@@ -294,12 +279,12 @@ public class ProcessManagerImplTest {
     ProcessEntity processArtifact =
         new ProcessEntity(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
     processArtifact.setArtifact(ByteBuffer.wrap("bla bla".getBytes()));
-    doReturn(processArtifact).when(vendorSoftwareProductDaoMock)
-        .getProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    doReturn(processArtifact).when(processDaoMock)
+        .getArtifact(any(ProcessEntity.class));
 
-    processManager.deleteProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID, USER1);
-    verify(vendorSoftwareProductDaoMock)
-        .deleteProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    processManager.deleteProcessArtifact(VSP_ID, VERSION, COMPONENT_ID, PROCESS1_ID);
+    verify(processDaoMock)
+        .deleteArtifact(any(ProcessEntity.class));
   }
 
 
@@ -315,10 +300,10 @@ public class ProcessManagerImplTest {
   private void testGet_negative(String vspId, Version version, String componentId, String processId,
                                 String user, String expectedErrorCode) {
     try {
-      processManager.getProcess(vspId, version, componentId, processId, user);
+      processManager.getProcess(vspId, version, componentId, processId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
@@ -328,10 +313,10 @@ public class ProcessManagerImplTest {
                                    String expectedErrorCode) {
     try {
       processManager
-          .updateProcess(new ProcessEntity(vspId, version, componentId, processId), user);
+          .updateProcess(new ProcessEntity(vspId, version, componentId, processId));
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
@@ -339,10 +324,10 @@ public class ProcessManagerImplTest {
   private void testGetFile_negative(String vspId, Version version, String componentId,
                                     String processId, String user, String expectedErrorCode) {
     try {
-      processManager.getProcessArtifact(vspId, version, componentId, processId, user);
+      processManager.getProcessArtifact(vspId, version, componentId, processId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
@@ -353,10 +338,10 @@ public class ProcessManagerImplTest {
     try {
       processManager
           .uploadProcessArtifact(new ByteArrayInputStream("bla bla".getBytes()), "artifact.sh",
-              vspId, version, componentId, processId, user);
+              vspId, version, componentId, processId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.error("",exception);
+      log.error("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
@@ -364,10 +349,10 @@ public class ProcessManagerImplTest {
   private void testDeleteArtifact_negative(String vspId, String componentId, String processId,
                                            String user, String expectedErrorCode) {
     try {
-      processManager.deleteProcessArtifact(vspId, VERSION, componentId, processId, user);
+      processManager.deleteProcessArtifact(vspId, VERSION, componentId, processId);
       Assert.fail();
     } catch (CoreException exception) {
-      log.debug("",exception);
+      log.debug("", exception);
       Assert.assertEquals(exception.code().id(), expectedErrorCode);
     }
   }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImplTest.java
index 5199dfd365..7721817c3b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/VendorSoftwareProductManagerImplTest.java
@@ -33,15 +33,12 @@ import org.openecomp.core.model.dao.ServiceModelDao;
 import org.openecomp.core.model.types.ServiceElement;
 import org.openecomp.core.utilities.file.FileContentHandler;
 import org.openecomp.core.utilities.file.FileUtils;
-import org.openecomp.sdc.activityLog.ActivityLogManager;
 import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.errors.ErrorCategory;
 import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.common.errors.Messages;
 import org.openecomp.sdc.healing.api.HealingManager;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
 import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
@@ -53,18 +50,16 @@ import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.DeploymentFlavorDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.PackageInfoDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.DeploymentFlavorEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.PackageInfo;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.UploadDataEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.mock.EnrichmentManagerFactoryImpl;
 import org.openecomp.sdc.vendorsoftwareproduct.informationArtifact.InformationArtifactGenerator;
 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionEntityDataManager;
 import org.openecomp.sdc.vendorsoftwareproduct.types.UploadFileResponse;
 import org.openecomp.sdc.vendorsoftwareproduct.types.ValidationResponse;
-import org.openecomp.sdc.vendorsoftwareproduct.types.VersionedVendorSoftwareProductInfo;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.DeploymentFlavor;
 import org.openecomp.sdc.versioning.VersioningManager;
 import org.openecomp.sdc.versioning.dao.types.Version;
@@ -94,7 +89,6 @@ import java.util.zip.ZipInputStream;
 
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
@@ -103,13 +97,10 @@ import static org.mockito.Mockito.verify;
 
 
 public class VendorSoftwareProductManagerImplTest {
-
-  private static final Logger LOG = LoggerFactory.getLogger(VendorSoftwareProductManagerImplTest.class);
-
   private static final String INVALID_VERSION_MSG = "Invalid requested version.";
 
-  private static final String VSP_ID = "vspId";
-  private static final String VERSION_ID = "versionId";
+  private static String VSP_ID = "vspId";
+  private static String VERSION_ID = "versionId";
   public static final Version VERSION01 = new Version(0, 1);
   private static final Version VERSION10 = new Version(1, 0);
   private static final String USER1 = "vspTestUser1";
@@ -121,8 +112,6 @@ public class VendorSoftwareProductManagerImplTest {
   @Mock
   private VersioningManager versioningManagerMock;
   @Mock
-  private VendorSoftwareProductDao vendorSoftwareProductDaoMock; // todo get rid of
-  @Mock
   private OrchestrationTemplateDao orchestrationTemplateDataDaoMock;
   @Mock
   private VendorLicenseFacade vendorLicenseFacadeMock;
@@ -139,8 +128,6 @@ public class VendorSoftwareProductManagerImplTest {
   @Mock
   private InformationArtifactGenerator informationArtifactGeneratorMock;
   @Mock
-  private ActivityLogManager activityLogManagerMock;
-  @Mock
   private PackageInfoDao packageInfoDao;
   @Mock
   private VendorSoftwareProductInfoDao vspInfoDaoMock;
@@ -164,14 +151,14 @@ public class VendorSoftwareProductManagerImplTest {
   public void setUp() throws Exception {
     MockitoAnnotations.initMocks(this);
   }
-
+/*
   @Test
   public void testListWhenNone() {
     doReturn(new HashMap<>()).when(versioningManagerMock).listEntitiesVersionInfo
-            (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
-                    VersionableEntityAction.Read);
+        (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
+            VersionableEntityAction.Read);
     List<VersionedVendorSoftwareProductInfo> vsps =
-            vendorSoftwareProductManager.listVsps(null, USER1);
+        vendorSoftwareProductManager.listVsps(null);
     Assert.assertEquals(vsps.size(), 0);
   }
 
@@ -190,16 +177,16 @@ public class VendorSoftwareProductManagerImplTest {
     vspsTobeReturned.put(vsp2id, versionInfo2);
 
     doReturn(vspsTobeReturned).when(versioningManagerMock).listEntitiesVersionInfo
-            (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
-                    VersionableEntityAction.Read);
+        (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
+            VersionableEntityAction.Read);
 
     VspDetails vsp1 = new VspDetails(vsp1id, VERSION01);
     vsp1.setWritetimeMicroSeconds(8L);
     doReturn(vsp1).when(vspInfoDaoMock)
-            .get(any(VspDetails.class));
+        .get(any(VspDetails.class));
 
     List<VersionedVendorSoftwareProductInfo> vsps =
-            vendorSoftwareProductManager.listVsps(null, USER1);
+        vendorSoftwareProductManager.listVsps(null);
     Assert.assertEquals(vsps.size(), 2);
   }
 
@@ -218,11 +205,11 @@ public class VendorSoftwareProductManagerImplTest {
     vspsTobeReturned.put(vsp2id, versionInfo2);
 
     doReturn(vspsTobeReturned).when(versioningManagerMock).listEntitiesVersionInfo
-            (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
-                    VersionableEntityAction.Read);
+        (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
+            VersionableEntityAction.Read);
 
     List<VersionedVendorSoftwareProductInfo> vsps =
-            vendorSoftwareProductManager.listVsps(VersionStatus.Final.name(), USER1);
+        vendorSoftwareProductManager.listVsps(VersionStatus.Certified.name());
     Assert.assertEquals(vsps.size(), 0);
   }
 
@@ -242,53 +229,36 @@ public class VendorSoftwareProductManagerImplTest {
     vspsTobeReturned.put(vsp2id, versionInfo2);
 
     doReturn(vspsTobeReturned).when(versioningManagerMock).listEntitiesVersionInfo
-            (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
-                    VersionableEntityAction.Read);
+        (VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, USER1,
+            VersionableEntityAction.Read);
 
     VspDetails vsp2 = new VspDetails(vsp2id, VERSION10);
     vsp2.setWritetimeMicroSeconds(8L);
     doReturn(vsp2).when(vspInfoDaoMock)
-            .get(any(VspDetails.class));
+        .get(any(VspDetails.class));
 
     List<VersionedVendorSoftwareProductInfo> vsps =
-            vendorSoftwareProductManager.listVsps(VersionStatus.Final.name(), USER1);
+        vendorSoftwareProductManager.listVsps(VersionStatus.Certified.name());
     Assert.assertEquals(vsps.size(), 1);
-  }
+  }*/
 
-  @Test(expectedExceptions = CoreException.class)
-  public void testCreateWithExistingName_negative() {
-    doThrow(new CoreException(
-            new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
-            .when(vendorSoftwareProductManager).validateUniqueName("Vsp1");
-    VspDetails expectedVsp =
-            createVspDetails(null, null, "Vsp1", "Test-vsp", "vendorName", "vlm1Id", "icon",
-                    "category", "subCategory", "123", null);
-
-    vendorSoftwareProductManager.createVsp(expectedVsp, USER1);
-  }
 
   @Test
   public void testCreate() {
-    doNothing().when(vendorSoftwareProductManager).validateUniqueName("Vsp1");
-    doNothing().when(vendorSoftwareProductManager).createUniqueName("Vsp1");
-    doReturn(VERSION01).when(versioningManagerMock).create(anyObject(), anyObject(), anyObject());
+    //doReturn(VERSION01).when(versioningManagerMock).create(anyObject(), anyObject(), anyObject());
     doReturn("{}")
-            .when(vendorSoftwareProductManager).getVspQuestionnaireSchema(anyObject());
+        .when(vendorSoftwareProductManager).getVspQuestionnaireSchema(anyObject());
 
     VspDetails vspToCreate =
-            createVspDetails(null, null, "Vsp1", "Test-vsp", "vendorName", "vlm1Id", "icon",
-                    "category", "subCategory", "123", null);
+        createVspDetails(null, null, "Vsp1", "Test-vsp", "vendorName", "vlm1Id", "icon",
+            "category", "subCategory", "123", null);
 
-    VspDetails vsp = vendorSoftwareProductManager.createVsp(vspToCreate, USER1);
+    VspDetails vsp = vendorSoftwareProductManager.createVsp(vspToCreate);
 
     Assert.assertNotNull(vsp);
     vspToCreate.setId(vsp.getId());
     vspToCreate.setVersion(VERSION01);
     assertVspsEquals(vsp, vspToCreate);
-    verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION01.getMajor() + 1));
-    Assert.assertTrue(activityLogEntity.isSuccess());
   }
 
   @Test(expectedExceptions = CoreException.class)
@@ -296,23 +266,23 @@ public class VendorSoftwareProductManagerImplTest {
     VersionInfo versionInfo = new VersionInfo();
     versionInfo.setActiveVersion(VERSION01);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
-            VersionableEntityAction.Write);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
+        VersionableEntityAction.Write);
 
     VspDetails existingVsp =
-            createVspDetails(VSP_ID, VERSION01, "Vsp1", "Test-existingVsp", "vendorName", "vlm1Id",
-                    "icon", "category", "subCategory", "123", null);
+        createVspDetails(VSP_ID, VERSION01, "Vsp1", "Test-existingVsp", "vendorName", "vlm1Id",
+            "icon", "category", "subCategory", "123", null);
     VspDetails updatedVsp =
-            createVspDetails(VSP_ID, VERSION01, "Vsp1_updated", "Test-existingVsp", "vendorName",
-                    "vlm1Id", "icon", "category", "subCategory", "123", null);
+        createVspDetails(VSP_ID, VERSION01, "Vsp1_updated", "Test-existingVsp", "vendorName",
+            "vlm1Id", "icon", "category", "subCategory", "123", null);
     doReturn(existingVsp).when(vspInfoDaoMock)
-            .get(any(VspDetails.class));
+        .get(any(VspDetails.class));
     doThrow(new CoreException(
-            new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
-            .when(vendorSoftwareProductManager)
-            .updateUniqueName(existingVsp.getName(), updatedVsp.getName());
+        new ErrorCode.ErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION).build()))
+        .when(vendorSoftwareProductManager)
+        .updateUniqueName(existingVsp.getName(), updatedVsp.getName());
 
-    vendorSoftwareProductManager.updateVsp(updatedVsp, USER1);
+    vendorSoftwareProductManager.updateVsp(updatedVsp);
   }
 
   @Test
@@ -320,23 +290,23 @@ public class VendorSoftwareProductManagerImplTest {
     VersionInfo versionInfo = new VersionInfo();
     versionInfo.setActiveVersion(VERSION01);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
-            VersionableEntityAction.Write);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
+        VersionableEntityAction.Write);
     VspDetails existingVsp =
-            createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
-                    "category",
-                    "subCategory", "456", null);
+        createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
+            "category",
+            "subCategory", "456", null);
     VspDetails updatedVsp =
-            createVspDetails(VSP_ID, VERSION01, "VSP1_updated", null, "vendorName", "vlm1Id", "icon",
-                    "category_updated",
-                    "subCategory", "456", null);
+        createVspDetails(VSP_ID, VERSION01, "VSP1_updated", null, "vendorName", "vlm1Id", "icon",
+            "category_updated",
+            "subCategory", "456", null);
     existingVsp.setWritetimeMicroSeconds(8L);
     doReturn(existingVsp).when(vspInfoDaoMock)
-            .get(any(VspDetails.class));
+        .get(any(VspDetails.class));
     doNothing().when(vendorSoftwareProductManager)
-            .updateUniqueName(existingVsp.getName(), updatedVsp.getName());
+        .updateUniqueName(existingVsp.getName(), updatedVsp.getName());
 
-    vendorSoftwareProductManager.updateVsp(updatedVsp, USER1);
+    vendorSoftwareProductManager.updateVsp(updatedVsp);
 
     verify(vspInfoDaoMock).update(updatedVsp);
   }
@@ -346,40 +316,41 @@ public class VendorSoftwareProductManagerImplTest {
     VersionInfo versionInfo = new VersionInfo();
     versionInfo.setActiveVersion(VERSION01);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
-            VersionableEntityAction.Write);
-    List<String> fgs = new ArrayList<>();
-    fgs.add("fg1"); fgs.add("fg2");
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
+        VersionableEntityAction.Write);
+    List<String> fgs = new ArrayList<String>();
+    fgs.add("fg1");
+    fgs.add("fg2");
     VspDetails existingVsp =
-            createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
-                    "category",
-                    "subCategory", "456", fgs);
+        createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
+            "category",
+            "subCategory", "456", fgs);
 
-    List<String> updFgs = new ArrayList<>();
-    updFgs.add("fg2");
+    List<String> updFgs = new ArrayList<String>();
+    //updFgs.add("fg2");
     VspDetails updatedVsp =
-            createVspDetails(VSP_ID, VERSION01, "VSP1_updated", null, "vendorName", "vlm1Id", "icon",
-                    "category_updated",
-                    "subCategory", "456", updFgs);
+        createVspDetails(VSP_ID, VERSION01, "VSP1_updated", null, "vendorName", "vlm1Id", "icon",
+            "category_updated",
+            "subCategory", "456", updFgs);
     existingVsp.setWritetimeMicroSeconds(8L);
     doReturn(existingVsp).when(vspInfoDaoMock)
-            .get(any(VspDetails.class));
+        .get(any(VspDetails.class));
     doNothing().when(vendorSoftwareProductManager)
-            .updateUniqueName(existingVsp.getName(), updatedVsp.getName());
+        .updateUniqueName(existingVsp.getName(), updatedVsp.getName());
 
-    DeploymentFlavorEntity dfEntity = new DeploymentFlavorEntity(VSP_ID,VERSION01,"DF_ID");
+    DeploymentFlavorEntity dfEntity = new DeploymentFlavorEntity(VSP_ID, VERSION01, "DF_ID");
     DeploymentFlavor flavor = new DeploymentFlavor();
     flavor.setFeatureGroupId("fg1");
     dfEntity.setDeploymentFlavorCompositionData(flavor);
 
-    List<DeploymentFlavorEntity> dfList = new ArrayList<>();
+    List<DeploymentFlavorEntity> dfList = new ArrayList<DeploymentFlavorEntity>();
     dfList.add(dfEntity);
 
     doReturn(dfList).when(deploymentFlavorDaoMock).list(anyObject());
 
-    vendorSoftwareProductManager.updateVsp(updatedVsp, USER1);
+    vendorSoftwareProductManager.updateVsp(updatedVsp);
 
-    verify(vendorSoftwareProductDaoMock).updateDeploymentFlavor(dfEntity);
+    verify(deploymentFlavorDaoMock).update(dfEntity);
 
     Assert.assertNull(dfEntity.getDeploymentFlavorCompositionData().getFeatureGroupId());
 
@@ -389,7 +360,7 @@ public class VendorSoftwareProductManagerImplTest {
   public void testGetNonExistingVersion_negative() {
     Version notExistversion = new Version(43, 8);
     doReturn(null).when(vspInfoDaoMock).get(any(VspDetails.class));
-    vendorSoftwareProductManager.getVsp(VSP_ID, notExistversion, USER1);
+    vendorSoftwareProductManager.getVsp(VSP_ID, notExistversion);
   }
 
   @Test
@@ -399,18 +370,18 @@ public class VendorSoftwareProductManagerImplTest {
     versionInfo.setStatus(VersionStatus.Locked);
     versionInfo.setLockingUser(USER1);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
-            VersionableEntityAction.Read);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
+        VersionableEntityAction.Read);
 
     VspDetails existingVsp =
-            createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
-                    "category",
-                    "subCategory", "456", null);
+        createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
+            "category",
+            "subCategory", "456", null);
     existingVsp.setWritetimeMicroSeconds(8L);
     doReturn(existingVsp).when(vspInfoDaoMock).get(any(VspDetails.class));
 
     VspDetails actualVsp =
-            vendorSoftwareProductManager.getVsp(VSP_ID, VERSION01, USER1);
+        vendorSoftwareProductManager.getVsp(VSP_ID, VERSION01);
 
     assertVspsEquals(actualVsp, existingVsp);
   }
@@ -423,84 +394,26 @@ public class VendorSoftwareProductManagerImplTest {
     versionInfo.setStatus(VersionStatus.Locked);
     versionInfo.setLockingUser(USER2);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
-            VersionableEntityAction.Read);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
+        VersionableEntityAction.Read);
 
     VspDetails existingVsp =
-            createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
-                    "category",
-                    "subCategory", "456", null);
+        createVspDetails(VSP_ID, VERSION01, "VSP1", null, "vendorName", "vlm1Id", "icon",
+            "category",
+            "subCategory", "456", null);
     existingVsp.setWritetimeMicroSeconds(8L);
     doReturn(existingVsp)
-            .when(vspInfoDaoMock).get(any(VspDetails.class));
+        .when(vspInfoDaoMock).get(any(VspDetails.class));
 
     VspDetails actualVsp =
-            vendorSoftwareProductManager.getVsp(VSP_ID, VERSION01, USER1);
+        vendorSoftwareProductManager.getVsp(VSP_ID, VERSION01);
 
     VspDetails expectedVsp =
-            vspInfoDaoMock
-                    .get(new VspDetails(VSP_ID, VERSION01));
+        vspInfoDaoMock
+            .get(new VspDetails(VSP_ID, VERSION01));
     assertVspsEquals(actualVsp, expectedVsp);
   }
 
-  @Test
-  public void testCheckin() {
-    doReturn(VERSION01).when(versioningManagerMock)
-            .checkin(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
-                    USER1, null);
-    Version version = vendorSoftwareProductManager.checkin(VSP_ID, USER1);
-
-    Assert.assertEquals(version, VERSION01);
-    verify(versioningManagerMock)
-            .checkin(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
-                    USER1, null);
-    verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION01.getMajor() + 1));
-    Assert.assertTrue(activityLogEntity.isSuccess());
-  }
-
-  @Test
-  public void testCheckout() {
-    doReturn(VERSION01).when(versioningManagerMock)
-            .checkout(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
-                    USER1);
-    Version version = vendorSoftwareProductManager.checkout(VSP_ID, USER1);
-
-    Assert.assertEquals(version, VERSION01);
-    verify(versioningManagerMock)
-            .checkout(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
-                    USER1);
-
-    verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION01.getMajor() + 1));
-    Assert.assertTrue(activityLogEntity.isSuccess());
-  }
-
-
-  @Test
-  public void testUndoCheckout() {
-    Version existingVersion = new Version(0, 2);
-    VersionInfo versionInfo = new VersionInfo();
-    versionInfo.setActiveVersion(existingVersion);
-    doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-            VSP_ID, USER1, VersionableEntityAction.Read);
-
-    doReturn(VERSION01).when(versioningManagerMock).undoCheckout(VendorSoftwareProductConstants
-            .VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1);
-
-    VspDetails vsp = new VspDetails(VSP_ID, existingVersion);
-    vsp.setName("ExistingName");
-    doReturn(vsp).when(vspInfoDaoMock).get(anyObject());
-    doNothing().when(vendorSoftwareProductManager).updateUniqueName(vsp.getName(), vsp.getName());
-
-    Version undoCheckoutVersion = vendorSoftwareProductManager.undoCheckout(VSP_ID, USER1);
-
-    Assert.assertEquals(undoCheckoutVersion, VERSION01);
-  }
-
 /*
   @Test
   public void testSubmitWithMissingData() throws IOException {
@@ -551,35 +464,33 @@ public class VendorSoftwareProductManagerImplTest {
     VersionInfo versionInfo = new VersionInfo();
     versionInfo.setActiveVersion(VERSION01);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
-            VSP_ID, USER1, VersionableEntityAction.Read);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE,
+        VSP_ID, USER1, VersionableEntityAction.Read);
 
     VspDetails vsp =
-            createVspDetails(VSP_ID, VERSION01, "Vsp1", "Test-vsp", "vendorName", "vlm1Id", "icon",
-                    "category", "subCategory", "licenseAgreementId",
-                    Collections.singletonList("featureGroupId"));
+        createVspDetails(VSP_ID, VERSION01, "Vsp1", "Test-vsp", "vendorName", "vlm1Id", "icon",
+            "category", "subCategory", "licenseAgreementId",
+            Collections.singletonList("featureGroupId"));
     doReturn(vsp).when(vspInfoDaoMock).get(anyObject());
-    UploadDataEntity uploadData = new UploadDataEntity(VSP_ID, VERSION01);
+    OrchestrationTemplateEntity uploadData = new OrchestrationTemplateEntity(VSP_ID, VERSION01);
     uploadData.setContentData(
-            ByteBuffer.wrap(getBytes("/emptyComposition")));
+        ByteBuffer.wrap(FileUtils.toByteArray(getFileInputStream("/emptyComposition"))));
     doReturn(uploadData).when(orchestrationTemplateDataDaoMock)
-            .getOrchestrationTemplate(anyObject(), anyObject());
+        .get(anyObject(), anyObject());
     doReturn(new ToscaServiceModel(new FileContentHandler(), new HashMap<>(),
-            "MainServiceTemplate.yaml"))
-            .when(serviceModelDaoMock).getServiceModel(VSP_ID, VERSION01);
+        "MainServiceTemplate.yaml"))
+        .when(serviceModelDaoMock).getServiceModel(VSP_ID, VERSION01);
 
-    ValidationResponse validationResponse = vendorSoftwareProductManager.submit(VSP_ID, USER1);
+    ValidationResponse validationResponse =
+        vendorSoftwareProductManager.validate(VSP_ID, VERSION01);
     Assert.assertNotNull(validationResponse);
     Assert.assertFalse(validationResponse.isValid());
     Assert.assertNull(validationResponse.getVspErrors());
-    Assert.assertEquals(validationResponse.getLicensingDataErrors(), 1);
+    Assert.assertEquals(validationResponse.getLicensingDataErrors().size(), 1);
 
     verify(versioningManagerMock, never())
-            .submit(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
-                    USER1, null);
-
-    //TODO - check..
-    verify(activityLogManagerMock, never()).addActionLog(any(ActivityLogEntity.class), eq(USER1));
+        .submit(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
+            USER1, null);
   }
 
   // TODO: 3/15/2017 fix and enable
@@ -589,40 +500,32 @@ public class VendorSoftwareProductManagerImplTest {
 
     EnrichmentManagerFactory.getInstance();
     AbstractFactoryBase
-            .registerFactory(EnrichmentManagerFactory.class, EnrichmentManagerFactoryImpl.class);
+        .registerFactory(EnrichmentManagerFactory.class, EnrichmentManagerFactoryImpl.class);
 
     VspDetails vsp =
-            createVspDetails(VSP_ID, VERSION01, "Vsp1", "Test-vsp", "vendorName", "vlm1Id", "icon",
-                    "category", "subCategory", "123", Collections.singletonList("fg1"));
+        createVspDetails(VSP_ID, VERSION01, "Vsp1", "Test-vsp", "vendorName", "vlm1Id", "icon",
+            "category", "subCategory", "123", Collections.singletonList("fg1"));
     doReturn(vsp).when(vspInfoDaoMock).get(anyObject());
-    UploadDataEntity uploadData = new UploadDataEntity(VSP_ID, VERSION01);
+    OrchestrationTemplateEntity uploadData = new OrchestrationTemplateEntity(VSP_ID, VERSION01);
     uploadData.setContentData(
-            ByteBuffer.wrap(getBytes("/emptyComposition")));
+        ByteBuffer.wrap(FileUtils.toByteArray(getFileInputStream("/emptyComposition"))));
     doReturn(uploadData).when(orchestrationTemplateDataDaoMock)
-            .getOrchestrationTemplate(anyObject(), anyObject());
+        .get(anyObject(), anyObject());
     doReturn(new ToscaServiceModel(new FileContentHandler(), new HashMap<>(),
-            "MainServiceTemplate.yaml"))
-            .when(serviceModelDaoMock).getServiceModel(VSP_ID, VERSION01);
+        "MainServiceTemplate.yaml"))
+        .when(serviceModelDaoMock).getServiceModel(VSP_ID, VERSION01);
 
-    ValidationResponse validationResponse = vendorSoftwareProductManager.submit(VSP_ID, USER1);
+    ValidationResponse validationResponse =
+        vendorSoftwareProductManager.validate(VSP_ID, VERSION01);
     Assert.assertTrue(validationResponse.isValid());
 
-/*    Assert.assertEquals(vsp2.getVersionInfo().getActiveVersion(), VERSION10);
-    Assert.assertEquals(vsp2.getVersionInfo().getStatus(), VersionStatus.Final);
+/*    Assert.assertEquals(vsp2.getVersionInfo().getVersion(), VERSION10);
+    Assert.assertEquals(vsp2.getVersionInfo().getStatus(), VersionStatus.Certified);
     Assert.assertNull(vsp2.getVersionInfo().getLockingUser());*/
 
     verify(versioningManagerMock)
-            .submit(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
-                    USER1, null);
-    verify(activityLogManagerMock).addActionLog(activityLogEntityArg.capture(), eq(USER1));
-    ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue();
-    Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION10.getMajor()));
-    Assert.assertTrue(activityLogEntity.isSuccess());
-  }
-
-  @Test(expectedExceptions = CoreException.class)
-  public void testCreatePackageOnNonFinalVersion_negative() throws IOException {
-    vendorSoftwareProductManager.createPackage(VSP_ID, VERSION01, USER1);
+        .submit(VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID,
+            USER1, null);
   }
 
   @Test
@@ -632,11 +535,11 @@ public class VendorSoftwareProductManagerImplTest {
     VersionInfo versionInfo = new VersionInfo();
     versionInfo.setActiveVersion(VERSION10);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
-            VersionableEntityAction.Read);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
+        VersionableEntityAction.Read);
 
     doReturn(new ToscaServiceModel(new FileContentHandler(), new HashMap<>(), "")).when
-            (enrichedServiceModelDaoMock).getServiceModel(VSP_ID, VERSION10);
+        (enrichedServiceModelDaoMock).getServiceModel(VSP_ID, VERSION10);
 
     VspDetails vsp = new VspDetails(VSP_ID, VERSION10);
     vsp.setVendorId("vendorId");
@@ -645,20 +548,20 @@ public class VendorSoftwareProductManagerImplTest {
     doReturn(vsp).when(vspInfoDaoMock).get(any(VspDetails.class));
 
     doReturn(new FileContentHandler()).when(licenseArtifactsServiceMock)
-            .createLicenseArtifacts(VSP_ID, vsp.getVendorId(), VERSION10, vsp.getFeatureGroups(),
-                    USER1);
+        .createLicenseArtifacts(VSP_ID, vsp.getVendorId(), VERSION10, vsp.getFeatureGroups()
+        );
 
-    PackageInfo packageInfo = vendorSoftwareProductManager.createPackage(VSP_ID, VERSION10, USER1);
+    PackageInfo packageInfo = vendorSoftwareProductManager.createPackage(VSP_ID, VERSION10);
     Assert.assertNotNull(packageInfo.getVspId());
   }
 
   // TODO: 3/15/2017 fix and enable
   //@Test(dependsOnMethods = {"testListFinals"})
   public void testUploadFileMissingFile() throws IOException {
+    try (InputStream zis = getFileInputStream("/vspmanager/zips/missingYml.zip")) {
 
-    try (InputStream zis = this.getClass().getResourceAsStream("/vspmanager/zips/missingYml.zip")) {
       UploadFileResponse uploadFileResponse =
-              candidateManager.upload(VSP_ID, VERSION01, zis, USER1, "zip", "missingYml");
+              candidateManager.upload(VSP_ID, VERSION01, zis, "zip", "file");
 
       Assert.assertEquals(uploadFileResponse.getErrors().size(), 0);
     }
@@ -667,38 +570,130 @@ public class VendorSoftwareProductManagerImplTest {
   // TODO: 3/15/2017 fix and enable
   //@Test(dependsOnMethods = {"testUploadFileMissingFile"})
   public void testUploadNotZipFile() throws IOException {
-
     URL url = this.getClass().getResource("/notZipFile");
 
-    try (InputStream inputStream = url.openStream()) {
-      candidateManager
-              .upload(VSP_ID, VERSION01,
-                      inputStream, USER1, "zip", "notZipFile");
-      candidateManager.process(VSP_ID, VERSION01, USER1);
+    try {
+      candidateManager.upload(VSP_ID, VERSION01, url.openStream(), "zip", "file");
+      candidateManager.process(VSP_ID, VERSION01);
     } catch (Exception ce) {
       Assert.assertEquals(ce.getMessage(), Messages.CREATE_MANIFEST_FROM_ZIP.getErrorMessage());
     }
+  }
+/*
+  @Test
+  public void testEnrichModelInSubmit() {
+    UniqueValueUtil
+        .deleteUniqueValue(VendorSoftwareProductConstants.UniqueValues.VENDOR_SOFTWARE_PRODUCT_NAME,
+            "VSP_syb");
+    VspDetails vspDetails = vendorSoftwareProductManager.createVsp(
+        createVspDetails(null, null, "VSP_syb", "Test-vsp_syb", "vendorName", "vlm1Id", "icon",
+            "category", "subCategory", "456", null), USER1);
+    String id = vspDetails.getId();
+
+    //upload file
+    InputStream zis = getFileInputStream("/vspmanager/zips/fullComposition.zip");
+    candidateManager.upload(id, VERSION01, zis, USER1);
+    OrchestrationTemplateActionResponse uploadFileResponse =
+        candidateManager.process(id, VERSION01, USER1);
+
+    //check in
+    vendorSoftwareProductManager.checkin(id, USER1);
+    //submit
+    try {
+      ValidationResponse result = vendorSoftwareProductManager.submit(id, USER1);
+    } catch (IOException exception) {
+      Assert.fail();
+    }
+    VersionedVendorSoftwareProductInfo details =
+        vendorSoftwareProductManager.getVsp(id, null, USER1);
+    Collection<ComponentEntity> components =vendorSoftwareProductManager
+        .listComponents(id, details.getVersionInfo().getVersion(), USER1);
+
+    ToscaServiceModel model =
+        (ToscaServiceModel) EnrichedServiceModelDaoFactory.getInstance().createInterface()
+            .getServiceModel(id, details.getVersionInfo().getVersion());
+
+    Map<String, CapabilityDefinition> capabilities = new HashMap<>();
+    for (ComponentEntity component : components) {
+      model.getServiceTemplates().
+          entrySet().
+          stream().
+          filter(entryValue -> entryValue.getValue() != null &&
+              entryValue.getValue().getNode_types() != null &&
+              entryValue.getValue().
+                  getNode_types().
+                  containsKey(component.getComponentCompositionData().getName())).
+          forEach(entryValue -> entryValue.getValue().getNode_types().
+              values().
+              stream().
+              filter(type -> MapUtils.isNotEmpty(type.getCapabilities())).
+              forEach(type -> type.getCapabilities().
+                  entrySet().
+                  forEach(entry -> addCapability(entryValue.getKey(), capabilities, entry.getKey(),
+                      entry.getValue()))));
+
+    }
+
+    Assert.assertNotNull(capabilities);
+  }
+
+  @Test(dependsOnMethods = {"testCreatePackage"})
+  public void testEnrichedFilesDeletedOnNewUpload() throws IOException {
+    Version activeVersion;
+
+    createPackageFromUpload(VSP_ID, USER1, "/fullComposition");
+    activeVersion = vendorSoftwareProductManager.getVsp(VSP_ID, null, USER1).getVersionInfo()
+        .getVersion();
+
+    List<ServiceArtifact> firstExternalArtifacts = enrichedServiceModelDaoMock
+        .getExternalArtifacts(VSP_ID, activeVersion);
+    ToscaServiceModel firstServiceModel = enrichedServiceModelDaoMock.getServiceModel(VSP_ID,
+        activeVersion);
+
+    createPackageFromUpload(VSP_ID, USER1, "/emptyComposition");
+    activeVersion = vendorSoftwareProductManager.getVsp(VSP_ID, null, USER1).getVersionInfo()
+        .getVersion();
+
+    List<ServiceArtifact> secondExternalArtifacts = enrichedServiceModelDaoMock
+        .getExternalArtifacts(VSP_ID, activeVersion);
+    ToscaServiceModel secondServiceModel = enrichedServiceModelDaoMock.getServiceModel(VSP_ID,
+        activeVersion);
+
+    Assert.assertNotEquals(firstExternalArtifacts, secondExternalArtifacts);
+    Assert.assertNotEquals(firstServiceModel, secondServiceModel);
 
-    verify(activityLogManagerMock, never()).addActionLog(any(ActivityLogEntity.class), eq(USER1));
   }
 
+  @Test(dependsOnMethods = {"testMibsDeletedInCsar"})
+  public void testServiceTemplatesAreDeletedInCsarOnNewUpload() throws IOException {
+    String nestedPath = "Definitions" + File.separator + "nested";
+
+    uploadFileAndProcess(VSP_ID, USER1, "/vspmanager/zips/fullCompositionNested.zip");
+    checkinSubmitCreatePackage(VSP_ID, USER1);
+    List<String> nestedFileNamesServiceTemplates =
+        getWantedFileNamesFromCsar(nestedPath);
+
+    uploadFileAndProcess(VSP_ID, USER1, "/vspmanager/zips/fullComposition.zip");
+    checkinSubmitCreatePackage(VSP_ID, USER1);
+    List<String> emptyNestedNamesList = getWantedFileNamesFromCsar(nestedPath);
+
+    Assert.assertEquals(emptyNestedNamesList.size(), 0);
+    Assert.assertNotEquals(emptyNestedNamesList.size(), nestedFileNamesServiceTemplates.size());
+  }*/
 
   private List<String> getWantedFileNamesFromCsar(String pathInCsar)
-          throws IOException {
-    File translatedFile = vendorSoftwareProductManager.getTranslatedFile(VSP_ID, VERSION10, USER1);
+      throws IOException {
+    File translatedFile = vendorSoftwareProductManager.getTranslatedFile(VSP_ID, VERSION10);
 
     return getFileNamesFromFolderInCsar(translatedFile,
-            pathInCsar);
+        pathInCsar);
   }
 
   private List<String> getFileNamesFromFolderInCsar(File csar, String folderName)
-          throws IOException {
-
+      throws IOException {
     List<String> fileNames = new ArrayList<>();
 
-    try (FileInputStream fileInputStream = new FileInputStream(csar);
-         ZipInputStream zip = new ZipInputStream(fileInputStream)) {
-
+    try (ZipInputStream zip = new ZipInputStream(new FileInputStream(csar))) {
       ZipEntry ze;
 
       while ((ze = zip.getNextEntry()) != null) {
@@ -711,28 +706,26 @@ public class VendorSoftwareProductManagerImplTest {
 
     return fileNames;
   }
-
-  private void createPackageFromUpload(String vspId, String user, String filePath)
-          throws IOException {
-    uploadFileAndProcess(vspId, user, filePath);
-    checkinSubmitCreatePackage(vspId, user);
-  }
-
-  private void uploadFileAndProcess(String vspId, String user, String filePath) throws IOException {
-    vendorSoftwareProductManager.checkout(vspId, user);
-
-    try (InputStream inputStream = this.getClass().getResourceAsStream(filePath)) {
-      candidateManager.upload(vspId, VERSION01, inputStream, user, "zip", "file");
-      candidateManager.process(vspId, VERSION01, user);
-    }
-  }
-
-  private void checkinSubmitCreatePackage(String vspId, String user) throws IOException {
-    vendorSoftwareProductManager.checkin(vspId, user);
-    ValidationResponse submitResponse = vendorSoftwareProductManager.submit(vspId, user);
-    Assert.assertTrue(submitResponse.isValid());
-    vendorSoftwareProductManager.createPackage(vspId, VERSION10, user);
-  }
+  /*
+  //Disabled for sonar null pointer issue for componentEntities
+  private Pair<String, String> uploadMib(String vspId, String user, String filePath,
+                                         String fileName) {
+    List<ComponentEntity> componentEntities = null;
+    //(List<ComponentEntity>) vendorSoftwareProductManager.listComponents(vspId, null, user);
+    monitoringUploadsManager.upload(getFileInputStream(filePath),
+        fileName, vspId,
+<<<<<<< HEAD
+        VERSION01, componentEntities.get(0).getId(), ArtifactType.SNMP_POLL);
+    //TODO: add validate of logActivity() func call
+=======
+        VERSION01, componentEntities.get(0).getId(), MonitoringUploadType.SNMP_POLL, user);
+    //TODO: add validate of addActionLog() func call
+>>>>>>> feature/Amdocs-ASDC-1710
+
+    return new ImmutablePair<>(componentEntities.get(0).getId(),
+        componentEntities.get(0).getComponentCompositionData()
+            .getDisplayName());
+  }*/
 
   // TODO: 3/15/2017 fix and enable
 /*
@@ -781,11 +774,11 @@ public class VendorSoftwareProductManagerImplTest {
 */
 
   private void testLegalUpload(String vspId, Version version, InputStream upload, String user) {
-    candidateManager.upload(vspId, VERSION01, upload, USER1, "zip", "file");
-    candidateManager.process(vspId, VERSION01, user);
+    candidateManager.upload(vspId, VERSION01, upload, "zip", "file");
+    candidateManager.process(vspId, VERSION01);
 
-    UploadDataEntity uploadData =
-            orchestrationTemplateDataDaoMock.getOrchestrationTemplate(vspId, version);
+    OrchestrationTemplateEntity uploadData =
+        orchestrationTemplateDataDaoMock.get(vspId, version);
     Assert.assertNotNull(uploadData);
   }
 
@@ -795,20 +788,40 @@ public class VendorSoftwareProductManagerImplTest {
     capabilities.put(entryValueKey + "_" + key, value);
   }
 
-  private byte[] getBytes(String fileName) throws IOException {
+  public InputStream getFileInputStream(String fileName) {
     URL url = this.getClass().getResource(fileName);
-    try (InputStream inputStream = url.openStream()) {
-      return FileUtils.toByteArray(inputStream);
+    try {
+      return url.openStream();
+    } catch (IOException exception) {
+      exception.printStackTrace();
+      return null;
     }
   }
 
-  private void assertVSPInWantedLocationInVSPList(String vspId, int location, String user) {
+/*  private void assertVSPInWantedLocationInVSPList(String vspId, int location, String user) {
     List<VersionedVendorSoftwareProductInfo> vspList =
-            vendorSoftwareProductManager.listVsps(null, user);
+        vendorSoftwareProductManager.listVsps(null);
     Assert.assertEquals(vspList.get(location).getVspDetails().getId(), vspId);
-  }
-
-
+  }*/
+
+
+  //  private void assertInfoArtifactIsInRightPathInCsar(String vspId, String zipFileName)
+//      throws IOException {
+//    ZipInputStream inputZipStream = new ZipInputStream(new FileInputStream(new File(zipFileName)));
+//    boolean isInfoArtifactInZip = false;
+//
+//    ZipEntry zipEntry;
+//    while ((zipEntry = inputZipStream.getNextEntry()) != null) {
+//      String currentEntryName = zipEntry.getName();
+//      if(currentEntryName.equals("Artifacts\\Informative\\Guide\\VSP_" +
+//          vspId + "_Information.txt")){
+//        isInfoArtifactInZip = true;
+//        break;
+//      }
+//    }
+//
+//    Assert.assertTrue(isInfoArtifactInZip);
+//  }
   static VspDetails createVspDetails(String id, Version version, String name, String desc,
                                      String vendorName, String vlm, String icon,
                                      String category, String subCategory,
@@ -842,30 +855,68 @@ public class VendorSoftwareProductManagerImplTest {
     Assert.assertEquals(actual.getFeatureGroups(), expected.getFeatureGroups());
   }
 
- // todo ********************** move to common **************************************
+
+//    @Test
+//    public void testDownloadFile() throws IOException {
+//        VspDetails expectedVsp = VSPCommon.createVspDetails(null, null, String.format("VSP-test-%s", vlm1Id), "Test-vsp", "vendorName", "vlm1Id", "icon", "category", "subCategory", "123", null);
+//        VspDetails createdVsp = vendorSoftwareProductManager.createVsp(expectedVsp, USER1);
+//
+//        id005 = createdVsp.getId();
+//        Assert.assertNotNull(id005);
+//        Assert.assertNotNull(createdVsp.getVersion());
+//
+//        try (InputStream zipInputStream = new ZipFileUtils().getZipInputStream("/legalUploadWithWarning")) {
+//
+//            UploadFileResponse uploadFileResponse = vendorSoftwareProductManager.upload(id005, zipInputStream, USER1);
+//            vendorSoftwareProductManager.process(id005, USER1);
+//            Optional<File> fileCandidate = vendorSoftwareProductManager.get(id005, USER1);
+//
+//            File latestHeatPackage = fileCandidate.get();
+//
+//            zipInputStream.reset();
+//            byte[] uploaded = IOUtils.toByteArray(zipInputStream);
+//
+//            Optional<FileContentHandler> zipContentMap = vendorSoftwareProductManager.getZipContentMap(uploadFileResponse, uploaded);
+//            FileContentHandler fileContentHandler = new FileContentHandler();
+//            if(zipContentMap.isPresent()){
+//                 fileContentHandler = zipContentMap.get();
+//            }
+//
+//            uploaded = IOUtils.toByteArray(fileContentHandler.getFiles().values());
+//
+//            byte[] downloaded;
+//            try (BufferedInputStream fileStream = new BufferedInputStream(new FileInputStream(latestHeatPackage))) {
+//                downloaded = IOUtils.toByteArray(fileStream);
+//            }
+//
+//            Assert.assertTrue(Arrays.equals(uploaded, downloaded));
+//        }
+//    }
+
+  // todo ********************** move to common **************************************
 
   private void mockVersioning(VersionableEntityAction action) {
     VersionInfo versionInfo = new VersionInfo();
     versionInfo.setActiveVersion(VERSION01);
     doReturn(versionInfo).when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
-            action);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1,
+        action);
   }
 
   private void mockVersioningEntityNotExist(VersionableEntityAction action, String vspId) {
     doThrow(new CoreException(new EntityNotExistErrorBuilder(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, vspId).build()))
-            .when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, vspId, USER1,
-            action);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, vspId).build()))
+        .when(versioningManagerMock).getEntityVersionInfo(
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, vspId, USER1,
+        action);
   }
 
   private void MockVersioningEntityLocked(VersionableEntityAction action) {
     doThrow(new CoreException(new EditOnEntityLockedByOtherErrorBuilder(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1)
-            .build()))
-            .when(versioningManagerMock).getEntityVersionInfo(
-            VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER2,
-            action);
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER1)
+        .build()))
+        .when(versioningManagerMock).getEntityVersionInfo(
+        VendorSoftwareProductConstants.VENDOR_SOFTWARE_PRODUCT_VERSIONABLE_TYPE, VSP_ID, USER2,
+        action);
   }
 }
\ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/mock/VendorSoftwareProductDaoFactoryMock.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/mock/VendorSoftwareProductDaoFactoryMock.java
deleted file mode 100644
index ede8620cf9..0000000000
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/mock/VendorSoftwareProductDaoFactoryMock.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package org.openecomp.sdc.vendorsoftwareproduct.impl.mock;
-
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDaoFactory;
-
-public class VendorSoftwareProductDaoFactoryMock extends VendorSoftwareProductDaoFactory {
-
-    @Override
-    public VendorSoftwareProductDao createInterface() {
-        return null;
-    }
-}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/CandidateServiceImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/CandidateServiceImplTest.java
index 3d98ab76c6..1c9d61b51b 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/CandidateServiceImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/CandidateServiceImplTest.java
@@ -30,7 +30,6 @@ import org.openecomp.sdc.datatypes.error.ErrorMessage;
 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
 import org.openecomp.sdc.heat.datatypes.structure.HeatStructureTree;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.ManifestCreator;
 import org.openecomp.sdc.vendorsoftwareproduct.services.impl.filedatastructuremodule.CandidateServiceImpl;
@@ -57,8 +56,6 @@ import static org.testng.Assert.assertTrue;
 public class CandidateServiceImplTest {
   @Mock
   private ManifestCreator manifestCreatorMock;
-  @Mock
-  private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
   @InjectMocks
   private CandidateServiceImpl candidateService;
 
@@ -95,7 +92,8 @@ public class CandidateServiceImplTest {
     //vspDetails.setOnboardingMethod(VSPCommon.OnboardingMethod.HEAT.name());
     vspDetails.setOnboardingMethod("HEAT");
 
-    FilesDataStructure structure = JsonUtil.json2Object(getExpectedJson(), FilesDataStructure.class);
+    FilesDataStructure structure =
+        JsonUtil.json2Object(getExpectedJson(), FilesDataStructure.class);
 
     Optional<ManifestContent> expectedManifest = getExpectedManifestJson();
     doReturn(expectedManifest)
@@ -191,7 +189,8 @@ public class CandidateServiceImplTest {
     fileData = createFileData("file1.yaml", true, FileData.Type.HEAT, null);
     mockFileData.add(fileData);
     fileData = createFileData("file1_vol.yaml", null, FileData.Type.HEAT_VOL, fileData);
-    fileData = createFileData("file1.env", null, FileData.Type.HEAT_ENV, mockFileData.get(1).getData().get(0));
+    fileData = createFileData("file1.env", null, FileData.Type.HEAT_ENV,
+        mockFileData.get(1).getData().get(0));
     mockFileData.add(createFileData("file2.sh", null, FileData.Type.OTHER, null));
     mockFileData.add(createFileData("file3.yml", null, FileData.Type.OTHER, null));
     mock.setData(mockFileData);
@@ -202,7 +201,7 @@ public class CandidateServiceImplTest {
                                   FileData fileDataToAddTo) {
     FileData fileData = new FileData();
     fileData.setFile(fileName);
-    if(isBase != null) {
+    if (isBase != null) {
       fileData.setBase(isBase);
     }
     fileData.setType(fileType);
@@ -211,11 +210,9 @@ public class CandidateServiceImplTest {
   }
 
   private void addFileDataToList(FileData fileDataToAddTo, FileData fileData) {
-    if(fileDataToAddTo != null)
-    {
+    if (fileDataToAddTo != null) {
       List<FileData> list = fileDataToAddTo.getData();
-      if(CollectionUtils.isEmpty(list))
-      {
+      if (CollectionUtils.isEmpty(list)) {
         list = new ArrayList<>();
       }
       list.add(fileData);
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionDataExtractorImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionDataExtractorImplTest.java
index 2f85f30dc5..9385d4a10c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionDataExtractorImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionDataExtractorImplTest.java
@@ -27,8 +27,8 @@ import org.openecomp.sdc.logging.api.Logger;
 import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
-import org.openecomp.sdc.tosca.services.ToscaUtil;
 import org.openecomp.sdc.tosca.services.ToscaExtensionYamlUtil;
+import org.openecomp.sdc.tosca.services.ToscaUtil;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Component;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionData;
 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
@@ -110,11 +110,12 @@ public class CompositionDataExtractorImplTest {
       try (InputStream yamlFile = new FileInputStream(file)) {
         ServiceTemplate serviceTemplateFromYaml =
             toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
-        serviceTemplates.put(ToscaUtil.getServiceTemplateFileName(serviceTemplateFromYaml), serviceTemplateFromYaml);
+        serviceTemplates.put(ToscaUtil.getServiceTemplateFileName(serviceTemplateFromYaml),
+            serviceTemplateFromYaml);
         try {
           yamlFile.close();
         } catch (IOException ignore) {
-          log.debug("",ignore);
+          log.debug("", ignore);
         }
       } catch (FileNotFoundException exception) {
         throw exception;
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionEntityDataManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionEntityDataManagerImplTest.java
index 1acd58d157..0d9245d779 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionEntityDataManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/impl/composition/CompositionEntityDataManagerImplTest.java
@@ -22,12 +22,10 @@ package org.openecomp.sdc.vendorsoftwareproduct.services.impl.composition;
 
 import org.apache.commons.collections.CollectionUtils;
 import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.openecomp.core.utilities.file.FileUtils;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ComponentEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NetworkEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.NicEntity;
@@ -43,6 +41,7 @@ import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -90,8 +89,6 @@ public class CompositionEntityDataManagerImplTest {
       "}";
 
   private Map<CompositionEntityId, Collection<String>> errorsById;
-  @Mock
-  private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
   @InjectMocks
   @Spy
   private CompositionEntityDataManagerImpl compositionEntityDataManager;
@@ -248,7 +245,7 @@ public class CompositionEntityDataManagerImplTest {
 
     Map<CompositionEntityId, Collection<String>> errorsById =
         compositionEntityDataManager.validateEntitiesQuestionnaire();
-    Assert.assertEquals(errorsById.size(), 0);
+    Assert.assertEquals(errorsById.size(), 1);
   }
 
   @Test(dependsOnMethods = "testNicAndComponentValidQuestionnaire")
@@ -259,9 +256,9 @@ public class CompositionEntityDataManagerImplTest {
 
     Map<CompositionEntityId, Collection<String>> errorsById =
         compositionEntityDataManager.validateEntitiesQuestionnaire();
-    Assert.assertEquals(errorsById.size(), 1);
+    Assert.assertEquals(errorsById.size(), 2);
 
-    CompositionEntityId component = errorsById.keySet().iterator().next();
+    CompositionEntityId component = new ArrayList<>(errorsById.keySet()).get(1);
     List<String> errors = (List<String>) errorsById.get(component);
     Assert.assertEquals(errors.size(), 1);
     Assert.assertEquals(errors.get(0),
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/schemagenerator/SchemaGeneratorTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/schemagenerator/SchemaGeneratorTest.java
index acd76a151b..237e9cce8f 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/schemagenerator/SchemaGeneratorTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/schemagenerator/SchemaGeneratorTest.java
@@ -20,27 +20,6 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator;
 
-import org.everit.json.schema.EmptySchema;
-import org.everit.json.schema.loader.SchemaLoader;
-import org.json.JSONObject;
-import org.openecomp.core.utilities.json.JsonUtil;
-import org.openecomp.sdc.vendorsoftwareproduct.services.schemagenerator.SchemaGenerator;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentData;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
-import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
-import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentCompositionSchemaInput;
-import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentQuestionnaireSchemaInput;
-import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.NetworkCompositionSchemaInput;
-import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.NicCompositionSchemaInput;
-import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
-import org.testng.Assert;
-import org.testng.annotations.Test;
-
-import java.util.Arrays;
-import java.util.Map;
-
 public class SchemaGeneratorTest {
   /*
 
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/tree/UploadFileTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/tree/UploadFileTest.java
index df386b12cd..2a475fe895 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/tree/UploadFileTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/tree/UploadFileTest.java
@@ -21,9 +21,6 @@
 package org.openecomp.sdc.vendorsoftwareproduct.tree;
 
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.doReturn;
-
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
@@ -32,13 +29,10 @@ import org.openecomp.core.model.dao.ServiceModelDao;
 import org.openecomp.core.model.types.ServiceElement;
 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
 import org.openecomp.sdc.healing.api.HealingManager;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.type.UploadDataEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.OrchestrationTemplateCandidateManagerImpl;
 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionDataExtractor;
@@ -50,7 +44,11 @@ import org.openecomp.sdc.versioning.dao.types.Version;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
 import java.util.zip.ZipOutputStream;
 
@@ -59,70 +57,69 @@ import static org.mockito.Mockito.doReturn;
 import static org.testng.Assert.assertEquals;
 
 public class UploadFileTest {
-    private static final String USER1 = "vspTestUser1";
-
-    public static final Version VERSION01 = new Version(0, 1);
-    @Mock
-    private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
-    @Mock
-    private OrchestrationTemplateDao orchestrationTemplateDataDaoMock;
-    @Spy
-    private CandidateServiceImpl candidateService;
-    @Mock
-    private HealingManager healingManagerMock;
-    @Mock
-    private CompositionDataExtractor compositionDataExtractorMock;
-    @Mock
-    private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDaoMock;
-    @Mock
-    private CompositionEntityDataManager compositionEntityDataManagerMock;
-    @Mock
-    private VendorSoftwareProductInfoDao vspInfoDaoMock;
-
-    @InjectMocks
-    private OrchestrationTemplateCandidateManagerImpl candidateManager;
-
-    private static String vlm1Id;
-    public static String id001 = null;
-    public static String id002 = null;
-
-    public static Version activeVersion002 = null;
-
-
-    @BeforeMethod
-    public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void testUploadFile() {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
-        candidateManager.upload(id001, activeVersion002, getZipInputStream("/legalUpload"), USER1, OnboardingTypesEnum.ZIP.toString(), "legalUpload");
-    }
-
-
-    private void testLegalUpload(String vspId, Version version, InputStream upload, String user) {
-        UploadFileResponse uploadFileResponse = candidateManager.upload(vspId, activeVersion002,
-            upload, user, OnboardingTypesEnum.ZIP.toString(),"file" );
-        assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.ZIP);
-        UploadDataEntity uploadData =
-                orchestrationTemplateDataDaoMock.getOrchestrationTemplate(vspId, version);
-
-    }
-
-    public InputStream getZipInputStream(String name) {
-        URL url = this.getClass().getResource(name);
-        File templateDir = new File(url.getFile());
-
-        ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        try (ZipOutputStream zos = new ZipOutputStream(baos)) {
-            VSPCommon.zipDir(templateDir, "", zos, true);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return new ByteArrayInputStream(baos.toByteArray());
+  private static final String USER1 = "vspTestUser1";
+
+  public static final Version VERSION01 = new Version(0, 1);
+
+  @Mock
+  private OrchestrationTemplateDao orchestrationTemplateDataDaoMock;
+  @Spy
+  private CandidateServiceImpl candidateService;
+  @Mock
+  private HealingManager healingManagerMock;
+  @Mock
+  private CompositionDataExtractor compositionDataExtractorMock;
+  @Mock
+  private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDaoMock;
+  @Mock
+  private CompositionEntityDataManager compositionEntityDataManagerMock;
+  @Mock
+  private VendorSoftwareProductInfoDao vspInfoDaoMock;
+
+  @InjectMocks
+  private OrchestrationTemplateCandidateManagerImpl candidateManager;
+
+  private static String vlm1Id;
+  public static String id001 = null;
+  public static String id002 = null;
+
+  public static Version activeVersion002 = null;
+
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  public void testUploadFile() {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+    candidateManager.upload(id001, activeVersion002, getZipInputStream("/legalUpload"),
+        OnboardingTypesEnum.ZIP.toString(), "legalUpload");
+  }
+
+
+  private void testLegalUpload(String vspId, Version version, InputStream upload, String user) {
+    UploadFileResponse uploadFileResponse = candidateManager.upload(vspId, activeVersion002,
+        upload, OnboardingTypesEnum.ZIP.toString(), "file");
+    assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.ZIP);
+    OrchestrationTemplateEntity uploadData = orchestrationTemplateDataDaoMock.get(vspId, version);
+
+  }
+
+  public InputStream getZipInputStream(String name) {
+    URL url = this.getClass().getResource(name);
+    File templateDir = new File(url.getFile());
+
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    try (ZipOutputStream zos = new ZipOutputStream(baos)) {
+      VSPCommon.zipDir(templateDir, "", zos, true);
+    } catch (IOException e) {
+      e.printStackTrace();
     }
+    return new ByteArrayInputStream(baos.toByteArray());
+  }
 
 
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/HeatCleanup/HeatCleanupOnNewUploadTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/HeatCleanup/HeatCleanupOnNewUploadTest.java
index 4d925c00cd..13f3859c0c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/HeatCleanup/HeatCleanupOnNewUploadTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/HeatCleanup/HeatCleanupOnNewUploadTest.java
@@ -38,7 +38,7 @@ public class HeatCleanupOnNewUploadTest {/*
     UploadDataEntity uploadDataEntity =
         vendorSoftwareProductDao.getUploadData(new UploadDataEntity(vspId, vspActiveVersion));
     Assert.assertTrue((uploadDataEntity.getContentData() != null) == exist);
-    Assert.assertTrue((uploadDataEntity.getValidationData() != null) == exist);
+    Assert.assertTrue((uploadDataEntity.getInfo() != null) == exist);
     Assert.assertTrue((uploadDataEntity.getPackageName() != null) == exist);
     Assert.assertTrue((uploadDataEntity.getPackageVersion() != null) == exist);
     //TODO: talio - delete enrich data on new upload
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/ManifestParsingTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/ManifestParsingTest.java
index 3332e81e36..ee451e0a3c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/ManifestParsingTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/ManifestParsingTest.java
@@ -7,52 +7,55 @@ import org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.Onboardin
 import java.io.IOException;
 import java.io.InputStream;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 public class ManifestParsingTest {
 
-    @Test
-    public void testSuccessfulParsing() throws IOException {
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/manifest/ValidTosca.mf")) {
-            OnboardingManifest onboardingManifest = new OnboardingManifest(is);
-            assertTrue(onboardingManifest.isValid());
-            assertEquals(onboardingManifest.getMetadata().size(), 4);
-            assertEquals(onboardingManifest.getSources().size(), 5);
-        }
+  @Test
+  public void testSuccessfulParsing() throws IOException {
+    try (InputStream is = getClass()
+        .getResourceAsStream("/vspmanager.csar/manifest/ValidTosca.mf")) {
+      OnboardingManifest onboardingManifest = new OnboardingManifest(is);
+      assertTrue(onboardingManifest.isValid());
+      assertEquals(onboardingManifest.getMetadata().size(), 4);
+      assertEquals(onboardingManifest.getSources().size(), 5);
     }
-
-    @Test
-    public void testNoMetadataParsing() throws IOException {
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/manifest/InvalidTosca1.mf")) {
-            OnboardingManifest onboardingManifest = new OnboardingManifest(is);
-            assertFalse(onboardingManifest.isValid());
-            assertTrue(onboardingManifest.getErrors().stream().
-                    filter(error -> error.contains(Messages.MANIFEST_INVALID_LINE.getErrorMessage().substring(0, 10)))
-                    .findAny().isPresent());
-        }
+  }
+
+  @Test
+  public void testNoMetadataParsing() throws IOException {
+    try (InputStream is = getClass()
+        .getResourceAsStream("/vspmanager.csar/manifest/InvalidTosca1.mf")) {
+      OnboardingManifest onboardingManifest = new OnboardingManifest(is);
+      assertFalse(onboardingManifest.isValid());
+      assertTrue(onboardingManifest.getErrors().stream().anyMatch(error -> error
+          .contains(Messages.MANIFEST_INVALID_LINE.getErrorMessage().substring(0, 10))));
     }
-
-    @Test
-    public void testBrokenMDParsing() throws IOException {
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/manifest/InvalidTosca2.mf")) {
-            OnboardingManifest onboardingManifest = new OnboardingManifest(is);
-            assertFalse(onboardingManifest.isValid());
-            assertTrue(onboardingManifest.getErrors().stream().
-                    filter(error -> error.contains(Messages.MANIFEST_INVALID_LINE.getErrorMessage().substring(0, 10)))
-                    .findAny().isPresent());
-        }
+  }
+
+  @Test
+  public void testBrokenMDParsing() throws IOException {
+    try (InputStream is = getClass()
+        .getResourceAsStream("/vspmanager.csar/manifest/InvalidTosca2.mf")) {
+      OnboardingManifest onboardingManifest = new OnboardingManifest(is);
+      assertFalse(onboardingManifest.isValid());
+      assertTrue(onboardingManifest.getErrors().stream().anyMatch(error -> error
+          .contains(Messages.MANIFEST_INVALID_LINE.getErrorMessage().substring(0, 10))));
     }
-
-    @Test
-    public void testNoMetaParsing() throws IOException {
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/manifest/InvalidTosca4.mf")) {
-            OnboardingManifest onboardingManifest = new OnboardingManifest(is);
-            assertFalse(onboardingManifest.isValid());
-            assertTrue(onboardingManifest.getErrors().stream().
-                    filter(error -> error.contains(Messages.MANIFEST_NO_METADATA.getErrorMessage().substring(0, 10)))
-                    .findAny().isPresent());
-        }
+  }
+
+  @Test
+  public void testNoMetaParsing() throws IOException {
+    try (InputStream is = getClass()
+        .getResourceAsStream("/vspmanager.csar/manifest/InvalidTosca4.mf")) {
+      OnboardingManifest onboardingManifest = new OnboardingManifest(is);
+      assertFalse(onboardingManifest.isValid());
+      assertTrue(onboardingManifest.getErrors().stream().anyMatch(error -> error
+          .contains(Messages.MANIFEST_NO_METADATA.getErrorMessage().substring(0, 10))));
     }
+  }
 
 
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/UploadCSARFileTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/UploadCSARFileTest.java
index a7fc0e1ba0..d574c9ee74 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/UploadCSARFileTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/upload/csar/UploadCSARFileTest.java
@@ -33,7 +33,6 @@ import org.openecomp.sdc.healing.api.HealingManager;
 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateCandidateDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.OrchestrationTemplateDao;
-import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
 import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
 import org.openecomp.sdc.vendorsoftwareproduct.impl.OrchestrationTemplateCandidateManagerImpl;
@@ -51,171 +50,163 @@ import java.io.InputStream;
 import java.util.List;
 import java.util.function.Predicate;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doReturn;
 
 public class UploadCSARFileTest {
-    private static final String USER1 = "vspTestUser1";
-
-    public static final Version VERSION01 = new Version(0, 1);
-
-    @Mock
-    private VendorSoftwareProductDao vendorSoftwareProductDaoMock;
-    @Mock
-    private OrchestrationTemplateDao orchestrationTemplateDataDaoMock;
-
-    @Spy
-    private CandidateServiceImpl candidateService;
-    @Mock
-    private HealingManager healingManagerMock;
-    @Mock
-    private CompositionDataExtractor compositionDataExtractorMock;
-    @Mock
-    private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDaoMock;
-    @Mock
-    private CompositionEntityDataManager compositionEntityDataManagerMock;
-    @Mock
-    private VendorSoftwareProductInfoDao vspInfoDaoMock;
-    @Mock
-    private OrchestrationTemplateCandidateDao orchestrationTemplateCandidateDao;
-    @Mock
-    private ManifestCreatorNamingConventionImpl manifestCreator;
-
-    private OrchestrationTemplateCandidateManagerImpl candidateManager;
-
-
-    public static String id001 = null;
-
-    public static Version activeVersion002 = null;
-
-
-    @BeforeMethod
-    public void setUp() throws Exception {
-        MockitoAnnotations.initMocks(this);
-        candidateService = new CandidateServiceImpl(manifestCreator,orchestrationTemplateCandidateDao);
-        candidateManager = new OrchestrationTemplateCandidateManagerImpl( vendorSoftwareProductDaoMock,
-                vspInfoDaoMock,
-                orchestrationTemplateDataDaoMock,
-                candidateService,  healingManagerMock,
-                compositionDataExtractorMock,
-                serviceModelDaoMock,
-                compositionEntityDataManagerMock,
-                null,
-                null,
-                null,
-                null,
-                null);
-    }
-
-    @Test
-    public void testSuccessfulUploadFile() throws Exception {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
-
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmock.csar")) {
-            UploadFileResponse uploadFileResponse = candidateManager.upload(id001, activeVersion002, is, USER1, "csar", "SDCmock");
-            assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
-            assertEquals(0, uploadFileResponse.getErrors().size());
-            assertTrue(uploadFileResponse.getErrors().isEmpty());
-        }
-    }
-
-    @Test
-    public void testFail1UploadFile() throws Exception {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
-
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockFail1.csar")) {
-            UploadFileResponse uploadFileResponse = candidateManager.upload(id001, activeVersion002, is, USER1,
-                    "csar", "SDCmockFail1");
-            assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
-            assertEquals(1, uploadFileResponse.getErrors().size());
-            assertTrue( uploadFileResponse.getErrors().values().stream()
-                    .filter(getListPredicate(Messages.CSAR_FILES_NOT_ALLOWED
-                            .getErrorMessage().substring(0, 7))).findAny().isPresent());
-        }
-    }
 
-    private Predicate<List<ErrorMessage>> getListPredicate(String substring) {
-        return error -> isEquals(substring, error);
+  public static final Version VERSION01 = new Version("0.1");
+
+  @Mock
+  private OrchestrationTemplateDao orchestrationTemplateDataDaoMock;
+  @Spy
+  private CandidateServiceImpl candidateService;
+  @Mock
+  private HealingManager healingManagerMock;
+  @Mock
+  private CompositionDataExtractor compositionDataExtractorMock;
+  @Mock
+  private ServiceModelDao<ToscaServiceModel, ServiceElement> serviceModelDaoMock;
+  @Mock
+  private CompositionEntityDataManager compositionEntityDataManagerMock;
+  @Mock
+  private VendorSoftwareProductInfoDao vspInfoDaoMock;
+  @Mock
+  private OrchestrationTemplateCandidateDao orchestrationTemplateCandidateDao;
+  @Mock
+  private ManifestCreatorNamingConventionImpl manifestCreator;
+
+  private OrchestrationTemplateCandidateManagerImpl candidateManager;
+
+
+  public static String id001 = null;
+
+  public static Version activeVersion002 = null;
+
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+    candidateService = new CandidateServiceImpl(manifestCreator, orchestrationTemplateCandidateDao);
+    candidateManager = new OrchestrationTemplateCandidateManagerImpl(vspInfoDaoMock,
+        candidateService, healingManagerMock);
+  }
+
+  @Test
+  public void testSuccessfulUploadFile() throws Exception {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+
+    try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmock.csar")) {
+      UploadFileResponse uploadFileResponse =
+          candidateManager.upload(id001, activeVersion002, is, "csar", "SDCmock");
+      assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
+      assertEquals(0, uploadFileResponse.getErrors().size());
+      assertTrue(uploadFileResponse.getErrors().isEmpty());
     }
-
-    private boolean isEquals(String substring, List<ErrorMessage> error) {
-        return error.iterator().next().getMessage().contains(substring);
+  }
+
+  @Test
+  public void testFail1UploadFile() throws Exception {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+
+    try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockFail1.csar")) {
+      UploadFileResponse uploadFileResponse =
+          candidateManager.upload(id001, activeVersion002, is,
+              "csar", "SDCmockFail1");
+      assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
+      assertEquals(1, uploadFileResponse.getErrors().size());
+      assertTrue(uploadFileResponse.getErrors().values().stream().anyMatch(
+          getListPredicate(Messages.CSAR_FILES_NOT_ALLOWED.getErrorMessage().substring(0, 7))));
     }
-
-    @Test
-    public void testFail2UploadFile() throws Exception {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
-
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockFail2.csar")) {
-            UploadFileResponse uploadFileResponse = candidateManager.upload(id001, activeVersion002, is, USER1,
-                    "csar", "SDCmockFail2");
-            assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
-            assertEquals(1, uploadFileResponse.getErrors().size());
-            assertTrue( uploadFileResponse.getErrors().values().stream()
-                    .filter(getListPredicate(Messages.CSAR_FILE_NOT_FOUND
-                            .getErrorMessage().substring(0,7))).findAny().isPresent());
-        }
+  }
+
+  private Predicate<List<ErrorMessage>> getListPredicate(String substring) {
+    return error -> isEquals(substring, error);
+  }
+
+  private boolean isEquals(String substring, List<ErrorMessage> error) {
+    return error.iterator().next().getMessage().contains(substring);
+  }
+
+  @Test
+  public void testFail2UploadFile() throws Exception {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+
+    try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockFail2.csar")) {
+      UploadFileResponse uploadFileResponse =
+          candidateManager.upload(id001, activeVersion002, is,
+              "csar", "SDCmockFail2");
+      assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
+      assertEquals(1, uploadFileResponse.getErrors().size());
+      assertTrue(uploadFileResponse.getErrors().values().stream().anyMatch(
+          getListPredicate(Messages.CSAR_FILE_NOT_FOUND.getErrorMessage().substring(0, 7))));
     }
-    @Test
-    public void testFail3UploadFile() throws Exception {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
-
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockFail3.csar")) {
-            UploadFileResponse uploadFileResponse = candidateManager.upload(id001, activeVersion002, is, USER1,
-                    "csar", "SDCmockFail3");
-            assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
-            assertEquals(1, uploadFileResponse.getErrors().size());
-        }
+  }
+
+  @Test
+  public void testFail3UploadFile() throws Exception {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+
+    try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockFail3.csar")) {
+      UploadFileResponse uploadFileResponse =
+          candidateManager.upload(id001, activeVersion002, is,
+              "csar", "SDCmockFail3");
+      assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
+      assertEquals(1, uploadFileResponse.getErrors().size());
     }
-
-    @Test
-    public void testUploadFileIsNotZip() throws Exception {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
-
-        try (InputStream is = new ByteArrayInputStream( "Thia is not a zip file".getBytes() );) {
-            UploadFileResponse uploadFileResponse = candidateManager.upload(id001, activeVersion002, is, USER1,
-                    "csar", "file");
-            assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
-            assertFalse(uploadFileResponse.getErrors().isEmpty());
-            assertTrue( uploadFileResponse.getErrors().values().stream()
-                    .filter(getListPredicate(Messages.CSAR_FILE_NOT_FOUND
-                            .getErrorMessage().substring(0,7))).findAny().isPresent());
-        }
+  }
+
+  @Test
+  public void testUploadFileIsNotZip() throws Exception {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+
+    try (InputStream is = new ByteArrayInputStream("Thia is not a zip file".getBytes());) {
+      UploadFileResponse uploadFileResponse =
+          candidateManager.upload(id001, activeVersion002, is,
+              "csar", "file");
+      assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
+      assertFalse(uploadFileResponse.getErrors().isEmpty());
+      assertTrue(uploadFileResponse.getErrors().values().stream().anyMatch(
+          getListPredicate(Messages.CSAR_FILE_NOT_FOUND.getErrorMessage().substring(0, 7))));
     }
-    @Test
-    public void testUploadFileIsEmpty() throws Exception {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
-
-        try (InputStream is = new ByteArrayInputStream( new byte[]{} )) {
-            UploadFileResponse uploadFileResponse = candidateManager.upload(id001,
-                activeVersion002, is, USER1, "csar", "file");
-            assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
-            assertEquals(1, uploadFileResponse.getErrors().size());
-        }
+  }
+
+  @Test
+  public void testUploadFileIsEmpty() throws Exception {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+
+    try (InputStream is = new ByteArrayInputStream(new byte[]{})) {
+      UploadFileResponse uploadFileResponse = candidateManager.upload(id001,
+          activeVersion002, is, "csar", "file");
+      assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
+      assertEquals(1, uploadFileResponse.getErrors().size());
     }
+  }
 
-    @Test
-    public void testMFError() throws Exception {
-        VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
-        doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
+  @Test
+  public void testMFError() throws Exception {
+    VspDetails vspDetails = new VspDetails("dummyId", new Version(1, 0));
+    doReturn(vspDetails).when(vspInfoDaoMock).get(any(VspDetails.class));
 
-        try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockBrokenMF.csar")) {
-            UploadFileResponse uploadFileResponse = candidateManager.upload(id001, activeVersion002, is, USER1, "csar", "SDCmockBrokenMF");
-            assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
-            assertEquals(1, uploadFileResponse.getErrors().size());
-            assertTrue( uploadFileResponse.getErrors()
-                    .values().stream()
-                    .filter(getListPredicate(Messages.MANIFEST_NO_METADATA.getErrorMessage())).findAny().isPresent());
+    try (InputStream is = getClass().getResourceAsStream("/vspmanager.csar/SDCmockBrokenMF.csar")) {
+      UploadFileResponse uploadFileResponse =
+          candidateManager.upload(id001, activeVersion002, is, "csar", "SDCmockBrokenMF");
+      assertEquals(uploadFileResponse.getOnboardingType(), OnboardingTypesEnum.CSAR);
+      assertEquals(1, uploadFileResponse.getErrors().size());
+      assertTrue(uploadFileResponse.getErrors().values().stream()
+          .anyMatch(getListPredicate(Messages.MANIFEST_NO_METADATA.getErrorMessage())));
 
-        }
     }
+  }
 
 
 }
diff --git a/openecomp-be/backend/pom.xml b/openecomp-be/backend/pom.xml
index a627ed0e7f..2d98aa5342 100644
--- a/openecomp-be/backend/pom.xml
+++ b/openecomp-be/backend/pom.xml
@@ -23,6 +23,8 @@
         <module>openecomp-sdc-application-config-manager</module>
         <module>openecomp-sdc-activity-log-manager</module>
         <module>openecomp-sdc-healthcheck-manager</module>
+        <module>openecomp-sdc-conflict-manager</module>
+        <module>openecomp-sdc-item-permissions-manager</module>
     </modules>