Onboarding foundation changes for ItemManager

Resolved conflicting changes

1. Split ItemManager to ASDCItemManager and ItemManager
2. ItemManager provides basic capability of item without collaboration
3. AsdcItemManager provides all capabilities of item including
   collaboration which are required by onboarding
4. ItemManager can be used by other services like activity spec to
   create a basic item without collaboration features.

Change-Id: I6c6dc34a2b1a1745c796099b70e359432e90f85e
Issue-ID: SDC-1039
Signed-off-by: sheetalm <sheetal.mudholkar@amdocs.com>

19 files changed, 1084 insertions, 602 deletions

diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ActionVersioningManager.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ActionVersioningManager.java
new file mode 100644
index 0000000000..3875e59f33
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ActionVersioningManager.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning;
+
+import java.util.List;
+import java.util.Map;
+import org.openecomp.sdc.versioning.dao.types.Revision;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.types.VersionCreationMethod;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+
+public interface ActionVersioningManager {
+
+  void register(String entityType, VersionableEntityMetadata entityMetadata);
+
+  Version create(String entityType, String entityId, String user);
+
+  void delete(String entityType, String entityId, String user);
+
+  void undoDelete(String entityType, String entityId, String user);
+
+  Version checkout(String entityType, String entityId, String user);
+
+  Version undoCheckout(String entityType, String entityId, String user);
+
+  Version checkin(String entityType, String entityId, String user, String checkinDescription);
+
+  Version submit(String entityType, String entityId, String user, String submitDescription);
+
+  VersionInfo getEntityVersionInfo(String entityType, String entityId, String user,
+      VersionableEntityAction action);
+
+  Map<String, VersionInfo> listEntitiesVersionInfo(String entityType, String user,
+      VersionableEntityAction action);
+
+  Map<String, VersionInfo> listDeletedEntitiesVersionInfo(String entityType, String user,
+      VersionableEntityAction action);
+
+
+  List<Version> list(String itemId); // TODO: 5/24/2017 filter (by status for example)
+
+  Version get(String itemId, Version version);
+
+  Version create(String itemId, Version version,
+      VersionCreationMethod creationMethod);
+
+  void submit(String itemId, Version version, String submitDescription);
+
+  void publish(String itemId, Version version, String message);
+
+  void sync(String itemId, Version version);
+
+  void forceSync(String itemId, Version version);
+
+  void revert(String itemId, Version version, String revisionId);
+
+  List<Revision> listRevisions(String itemId, Version version);
+
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ActionVersioningManagerFactory.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ActionVersioningManagerFactory.java
new file mode 100644
index 0000000000..4ab659ac11
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ActionVersioningManagerFactory.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+public abstract class ActionVersioningManagerFactory extends
+    AbstractComponentFactory<ActionVersioningManager> {
+
+  public static ActionVersioningManagerFactory getInstance() {
+    return AbstractFactory.getInstance(ActionVersioningManagerFactory.class);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/AsdcItemManager.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/AsdcItemManager.java
new file mode 100644
index 0000000000..a4ea65fa08
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/AsdcItemManager.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.Item;
+
+public interface AsdcItemManager {
+
+  Collection<Item> list(Predicate<Item> predicate);
+
+  Item get(String itemId);
+
+  Item create(Item item);
+
+  void updateVersionStatus(String itemId, VersionStatus addedVersionStatus,
+      VersionStatus removedVersionStatus);
+
+  void updateOwner(String itemId, String owner);
+
+  void updateName(String itemId, String name);
+
+  void delete(Item item);
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/AsdcItemManagerFactory.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/AsdcItemManagerFactory.java
new file mode 100644
index 0000000000..a2095b8663
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/AsdcItemManagerFactory.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+public abstract class AsdcItemManagerFactory extends AbstractComponentFactory<AsdcItemManager> {
+
+  public static AsdcItemManagerFactory getInstance() {
+    return AbstractFactory.getInstance(AsdcItemManagerFactory.class);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManager.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManager.java
index 885d96a132..41a2c12058 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManager.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManager.java
@@ -1,10 +1,25 @@
-package org.openecomp.sdc.versioning;
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-import org.openecomp.sdc.versioning.dao.types.VersionStatus;
-import org.openecomp.sdc.versioning.types.Item;
+package org.openecomp.sdc.versioning;
 
 import java.util.Collection;
 import java.util.function.Predicate;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.Item;
 
 public interface ItemManager {
 
@@ -15,10 +30,11 @@ public interface ItemManager {
   Item create(Item item);
 
   void updateVersionStatus(String itemId, VersionStatus addedVersionStatus,
-                           VersionStatus removedVersionStatus);
-
-  void updateOwner(String itemId, String owner);
+      VersionStatus removedVersionStatus);
 
   void delete(Item item);
 
+  void updateName(String itemId, String name);
+
+  void update(Item item);
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/VersioningManager.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/VersioningManager.java
index c03769462b..cbb234e3e2 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/VersioningManager.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/VersioningManager.java
@@ -1,69 +1,34 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *   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.versioning;
 
+import java.util.List;
 import org.openecomp.sdc.versioning.dao.types.Revision;
 import org.openecomp.sdc.versioning.dao.types.Version;
 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
-import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
-
-import java.util.List;
-import java.util.Map;
 
 public interface VersioningManager {
 
-  void register(String entityType, VersionableEntityMetadata entityMetadata);
-
-  Version create(String entityType, String entityId, String user);
-
-  void delete(String entityType, String entityId, String user);
-
-  void undoDelete(String entityType, String entityId, String user);
-
-  Version checkout(String entityType, String entityId, String user);
-
-  Version undoCheckout(String entityType, String entityId, String user);
-
-  Version checkin(String entityType, String entityId, String user, String checkinDescription);
-
-  Version submit(String entityType, String entityId, String user, String submitDescription);
-
-  VersionInfo getEntityVersionInfo(String entityType, String entityId, String user,
-                                   VersionableEntityAction action);
-
-  Map<String, VersionInfo> listEntitiesVersionInfo(String entityType, String user,
-                                                   VersionableEntityAction action);
-
-  Map<String, VersionInfo> listDeletedEntitiesVersionInfo(String entityType, String user,
-                                                          VersionableEntityAction action);
-
-
   List<Version> list(String itemId); // TODO: 5/24/2017 filter (by status for example)
 
   Version get(String itemId, Version version);
 
   Version create(String itemId, Version version,
-                 VersionCreationMethod creationMethod);
+      VersionCreationMethod creationMethod);
 
   void submit(String itemId, Version version, String submitDescription);
 
@@ -77,4 +42,5 @@ public interface VersioningManager {
 
   List<Revision> listRevisions(String itemId, Version version);
 
+  void updateVersion(String itemId, Version version);
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/resources/factoryConfiguration.json b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/resources/factoryConfiguration.json
index 90d11f1700..579f107178 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/resources/factoryConfiguration.json
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/resources/factoryConfiguration.json
@@ -1,6 +1,8 @@
 {
   "org.openecomp.sdc.versioning.ItemManagerFactory": "org.openecomp.sdc.versioning.impl.ItemManagerFactoryImpl",
+  "org.openecomp.sdc.versioning.AsdcItemManagerFactory": "org.openecomp.sdc.versioning.impl.AsdcItemManagerFactoryImpl",
   "org.openecomp.sdc.versioning.VersioningManagerFactory": "org.openecomp.sdc.versioning.impl.VersioningManagerFactoryImpl",
+  "org.openecomp.sdc.versioning.ActionVersioningManagerFactory": "org.openecomp.sdc.versioning.impl.ActionVersioningManagerFactoryImpl",
   "org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory": "org.openecomp.sdc.versioning.dao.impl.VersionableEntityDaoFactoryImpl",
   "org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory": "org.openecomp.sdc.versioning.dao.impl.VersionInfoDaoFactoryImpl",
   "org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory": "org.openecomp.sdc.versioning.dao.impl.VersionInfoDeletedDaoFactoryImpl",
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java
index 46c6a9d795..f26164a9d3 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java
@@ -1,30 +1,27 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *   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.versioning.dao.impl;
 
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
 import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
 
 public class VersionInfoDaoFactoryImpl extends VersionInfoDaoFactory {
-  private static VersionInfoDao INSTANCE = new VersionInfoDaoImpl();
+  private static VersionInfoDao INSTANCE = new VersionInfoDaoImpl(NoSqlDbFactory.getInstance().createInterface());
 
   @Override
   public VersionInfoDao createInterface() {
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java
index 7bc73ce3d5..1afc4202f5 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java
@@ -1,21 +1,17 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *   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.versioning.dao.impl;
@@ -24,22 +20,26 @@ import com.datastax.driver.mapping.Mapper;
 import com.datastax.driver.mapping.Result;
 import com.datastax.driver.mapping.annotations.Accessor;
 import com.datastax.driver.mapping.annotations.Query;
+import java.util.Collection;
 import org.openecomp.core.dao.impl.CassandraBaseDao;
 import org.openecomp.core.nosqldb.api.NoSqlDb;
-import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
 
-import java.util.Collection;
-
 public class VersionInfoDaoImpl extends CassandraBaseDao<VersionInfoEntity>
     implements VersionInfoDao {
 
-  private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
-  private static Mapper<VersionInfoEntity> mapper =
-      noSqlDb.getMappingManager().mapper(VersionInfoEntity.class);
-  private static VersionInfoAccessor accessor =
-      noSqlDb.getMappingManager().createAccessor(VersionInfoAccessor.class);
+
+  private final NoSqlDb noSqlDb;
+  private final Mapper<VersionInfoEntity> mapper;
+  private final VersionInfoAccessor accessor;
+
+
+  public VersionInfoDaoImpl(NoSqlDb noSqlDb) {
+    this.noSqlDb = noSqlDb;
+    this.mapper = this.noSqlDb.getMappingManager().mapper(VersionInfoEntity.class);
+    this.accessor = this.noSqlDb.getMappingManager().createAccessor(VersionInfoAccessor.class);
+  }
 
   @Override
   protected Mapper<VersionInfoEntity> getMapper() {
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ActionVersioningManagerFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ActionVersioningManagerFactoryImpl.java
new file mode 100644
index 0000000000..054a569958
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ActionVersioningManagerFactoryImpl.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.sdc.versioning.ActionVersioningManager;
+import org.openecomp.sdc.versioning.ActionVersioningManagerFactory;
+import org.openecomp.sdc.versioning.AsdcItemManagerFactory;
+import org.openecomp.sdc.versioning.VersionCalculatorFactory;
+import org.openecomp.sdc.versioning.dao.VersionDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+
+public class ActionVersioningManagerFactoryImpl extends ActionVersioningManagerFactory {
+
+
+  @Override
+  public ActionVersioningManager createInterface() {
+    return new ActionVersioningManagerImpl(
+        VersionInfoDaoFactory.getInstance().createInterface(),
+        VersionInfoDeletedDaoFactory.getInstance().createInterface(),
+        VersionDaoFactory.getInstance().createInterface(),
+        VersionCalculatorFactory.getInstance().createInterface(),
+        AsdcItemManagerFactory.getInstance().createInterface());
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ActionVersioningManagerImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ActionVersioningManagerImpl.java
new file mode 100644
index 0000000000..0763ad970b
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ActionVersioningManagerImpl.java
@@ -0,0 +1,630 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning.impl;
+
+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 java.util.stream.Collectors;
+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.versioning.ActionVersioningManager;
+import org.openecomp.sdc.versioning.AsdcItemManager;
+import org.openecomp.sdc.versioning.VersionCalculator;
+import org.openecomp.sdc.versioning.dao.VersionDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory;
+import org.openecomp.sdc.versioning.dao.types.Revision;
+import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
+import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.errors.CheckinOnEntityLockedByOtherErrorBuilder;
+import org.openecomp.sdc.versioning.errors.CheckinOnUnlockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.CheckoutOnLockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.DeleteOnLockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EditOnEntityLockedByOtherErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EditOnUnlockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EntityAlreadyExistErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EntityAlreadyFinalizedErrorBuilder;
+import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder;
+import org.openecomp.sdc.versioning.errors.SubmitLockedEntityNotAllowedErrorBuilder;
+import org.openecomp.sdc.versioning.errors.UndoCheckoutOnEntityLockedByOtherErrorBuilder;
+import org.openecomp.sdc.versioning.errors.UndoCheckoutOnUnlockedEntityErrorBuilder;
+import org.openecomp.sdc.versioning.types.VersionCreationMethod;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+import org.slf4j.MDC;
+
+public class ActionVersioningManagerImpl implements ActionVersioningManager {
+  private static final Logger LOGGER = LoggerFactory.getLogger(ActionVersioningManagerImpl.class);
+  private static final Version INITIAL_ACTIVE_VERSION = new Version(0, 0);
+  private static final Map<String, Set<VersionableEntityMetadata>> VERSIONABLE_ENTITIES =
+      new HashMap<>();
+
+  private final VersionInfoDao versionInfoDao;
+  private final VersionInfoDeletedDao versionInfoDeletedDao;
+  private VersionDao versionDao;
+  private VersionCalculator versionCalculator;
+  private AsdcItemManager asdcItemManager;
+
+  public ActionVersioningManagerImpl(VersionInfoDao versionInfoDao,
+                                     VersionInfoDeletedDao versionInfoDeletedDao,
+                                     VersionDao versionDao,
+                                     VersionCalculator versionCalculator,
+                                     AsdcItemManager asdcItemManager) {
+    this.versionInfoDao = versionInfoDao;
+    this.versionInfoDeletedDao = versionInfoDeletedDao;
+    this.versionDao = versionDao;
+    this.versionCalculator = versionCalculator;
+    this.asdcItemManager = asdcItemManager;
+  }
+
+  private static VersionInfo getVersionInfo(VersionInfoEntity versionInfoEntity, String user,
+                                            VersionableEntityAction action) {
+    return getVersionInfo(versionInfoEntity.getEntityId(),
+        versionInfoEntity.getEntityType(),
+        versionInfoEntity.getActiveVersion(),
+        versionInfoEntity.getCandidate(),
+        versionInfoEntity.getStatus(),
+        versionInfoEntity.getLatestFinalVersion(),
+        versionInfoEntity.getViewableVersions(),
+        action,
+        user);
+  }
+
+  private static VersionInfo getVersionInfo(VersionInfoDeletedEntity versionInfoEntity, String user,
+                                            VersionableEntityAction action) {
+    return getVersionInfo(versionInfoEntity.getEntityId(),
+        versionInfoEntity.getEntityType(),
+        versionInfoEntity.getActiveVersion(),
+        versionInfoEntity.getCandidate(),
+        versionInfoEntity.getStatus(),
+        versionInfoEntity.getLatestFinalVersion(),
+        versionInfoEntity.getViewableVersions(),
+        action,
+        user);
+  }
+
+  private static VersionInfo getVersionInfo(String entityId, String entityType, Version activeVer,
+                                            UserCandidateVersion candidate, VersionStatus status,
+                                            Version latestFinalVersion,
+                                            Set<Version> viewableVersions,
+                                            VersionableEntityAction action, String user) {
+    Version activeVersion;
+
+    if (action == VersionableEntityAction.Write) {
+      if (candidate != null) {
+        if (user.equals(candidate.getUser())) {
+          activeVersion = candidate.getVersion();
+        } else {
+          throw new CoreException(
+              new EditOnEntityLockedByOtherErrorBuilder(entityType, entityId, candidate.getUser())
+                  .build());
+        }
+      } else {
+        throw new CoreException(new EditOnUnlockedEntityErrorBuilder(entityType, entityId).build());
+      }
+    } else {
+      if (candidate != null && user.equals(candidate.getUser())) {
+        activeVersion = candidate.getVersion();
+      } else {
+        activeVersion = activeVer;
+      }
+    }
+
+    VersionInfo versionInfo = new VersionInfo();
+    versionInfo.setStatus(status);
+    activeVersion.setStatus(status);
+    if (latestFinalVersion != null) {
+      latestFinalVersion.setStatus(status);
+    }
+    if (viewableVersions != null) {
+      viewableVersions.forEach(version -> version.setStatus(status));
+    }
+    versionInfo.setActiveVersion(activeVersion);
+    versionInfo.setLatestFinalVersion(latestFinalVersion);
+    versionInfo.setViewableVersions(toSortedList(viewableVersions));
+    versionInfo.setFinalVersions(getFinalVersions(viewableVersions));
+    if (candidate != null) {
+      candidate.getVersion().setStatus(status);
+      versionInfo.setLockingUser(candidate.getUser());
+      if (user.equals(candidate.getUser())) {
+        versionInfo.getViewableVersions().add(candidate.getVersion());
+      }
+    }
+    return versionInfo;
+  }
+
+  private static List<Version> toSortedList(
+      Set<Version> versions) { // changing the Set to List in DB will require migration...
+    return versions.stream().sorted((o1, o2) -> o1.getMajor() > o2.getMajor() ? 1
+        : o1.getMajor() == o2.getMajor() ? (o1.getMinor() > o2.getMinor() ? 1
+            : o1.getMinor() == o2.getMinor() ? 0 : -1) : -1).collect(Collectors.toList());
+  }
+
+  private static List<Version> getFinalVersions(Set<Version> versions) {
+    return versions.stream().filter(Version::isFinal).collect(Collectors.toList());
+  }
+
+  @Override
+  public void register(String entityType, VersionableEntityMetadata entityMetadata) {
+    Set<VersionableEntityMetadata> entitiesMetadata =
+        VERSIONABLE_ENTITIES.computeIfAbsent(entityType, k -> new HashSet<>());
+    entitiesMetadata.add(entityMetadata);
+  }
+
+  @Override
+  public Version create(String entityType, String entityId, String user) {
+    VersionInfoEntity
+        versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+    if (versionInfoEntity != null) {
+      throw new CoreException(new EntityAlreadyExistErrorBuilder(entityType, entityId).build());
+    }
+
+    versionInfoEntity = new VersionInfoEntity(entityType, entityId);
+    versionInfoEntity.setActiveVersion(INITIAL_ACTIVE_VERSION);
+    markAsCheckedOut(versionInfoEntity, user);
+    versionInfoDao.create(versionInfoEntity);
+
+    return versionInfoEntity.getCandidate().getVersion();
+  }
+
+  @Override
+  public void delete(String entityType, String entityId, String user) {
+    VersionInfoEntity versionInfoEntity =
+        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+    if (versionInfoEntity == null) {
+      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+    }
+
+    switch (versionInfoEntity.getStatus()) {
+      case Locked:
+        throw new CoreException(new DeleteOnLockedEntityErrorBuilder(entityType, entityId,
+            versionInfoEntity.getCandidate().getUser()).build());
+      default:
+        //do nothing
+        break;
+    }
+
+    doDelete(versionInfoEntity);
+  }
+
+  @Override
+  public void undoDelete(String entityType, String entityId, String user) {
+    VersionInfoDeletedEntity versionInfoDeletedEntity =
+        versionInfoDeletedDao.get(new VersionInfoDeletedEntity(entityType, entityId));
+    if (versionInfoDeletedEntity == null) {
+    throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+  }
+
+  doUndoDelete(versionInfoDeletedEntity);
+}
+
+  @Override
+  public Version checkout(String entityType, String entityId, String user) {
+    VersionInfoEntity versionInfoEntity =
+        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+    if (versionInfoEntity == null) {
+      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+    }
+
+    Version checkoutVersion = null;
+    switch (versionInfoEntity.getStatus()) {
+      case Locked:
+        throw new CoreException(new CheckoutOnLockedEntityErrorBuilder(entityType, entityId,
+            versionInfoEntity.getCandidate().getUser()).build());
+      case Certified:
+      case Draft:
+        checkoutVersion = doCheckout(versionInfoEntity, user);
+        break;
+      default:
+        //do nothing
+        break;
+    }
+
+    return checkoutVersion;
+  }
+
+  @Override
+  public Version undoCheckout(String entityType, String entityId, String user) {
+    VersionInfoEntity versionInfoEntity =
+        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+    if (versionInfoEntity == null) {
+      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+    }
+
+    Version activeVersion = null;
+    switch (versionInfoEntity.getStatus()) {
+      case Locked:
+        if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
+          throw new CoreException(
+              new UndoCheckoutOnEntityLockedByOtherErrorBuilder(entityType, entityId,
+                  versionInfoEntity.getCandidate().getUser()).build());
+        }
+        activeVersion = undoCheckout(versionInfoEntity);
+        break;
+      case Certified:
+      case Draft:
+        throw new CoreException(
+            new UndoCheckoutOnUnlockedEntityErrorBuilder(entityType, entityId).build());
+      default:
+        //do nothing
+        break;
+    }
+
+    return activeVersion;
+  }
+
+  private Version undoCheckout(VersionInfoEntity versionInfoEntity) {
+    deleteVersionFromEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+        versionInfoEntity.getCandidate().getVersion(), versionInfoEntity.getActiveVersion());
+
+    versionInfoEntity
+        .setStatus(versionInfoEntity.getActiveVersion().isFinal() ? VersionStatus.Certified
+            : VersionStatus.Draft);
+    versionInfoEntity.setCandidate(null);
+    versionInfoDao.update(versionInfoEntity);
+    return versionInfoEntity.getActiveVersion();
+  }
+
+  @Override
+  public Version checkin(String entityType, String entityId, String user,
+                         String checkinDescription) {
+    VersionInfoEntity versionInfoEntity =
+        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+    if (versionInfoEntity == null) {
+      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+    }
+
+    Version checkedInVersion = null;
+    switch (versionInfoEntity.getStatus()) {
+      case Draft:
+      case Certified:
+        throw new CoreException(
+            new CheckinOnUnlockedEntityErrorBuilder(entityType, entityId).build());
+      case Locked:
+        if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
+          throw new CoreException(new CheckinOnEntityLockedByOtherErrorBuilder(entityType, entityId,
+              versionInfoEntity.getCandidate().getUser()).build());
+        }
+        checkedInVersion = doCheckin(versionInfoEntity, checkinDescription);
+        break;
+      default:
+        //do nothing
+        break;
+    }
+
+    return checkedInVersion;
+  }
+
+  @Override
+  public Version submit(String entityType, String entityId, String user, String submitDescription) {
+    VersionInfoEntity versionInfoEntity =
+        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+    if (versionInfoEntity == null) {
+      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+    }
+
+    Version submitVersion = null;
+    switch (versionInfoEntity.getStatus()) {
+      case Certified:
+        throw new CoreException(
+            new EntityAlreadyFinalizedErrorBuilder(entityType, entityId).build());
+      case Locked:
+        throw new CoreException(new SubmitLockedEntityNotAllowedErrorBuilder(entityType, entityId,
+            versionInfoEntity.getCandidate().getUser()).build());
+      case Draft:
+        submitVersion = doSubmit(versionInfoEntity, user, submitDescription);
+        break;
+      default:
+        //do nothing
+        break;
+    }
+
+    return submitVersion;
+  }
+
+  @Override
+  public VersionInfo getEntityVersionInfo(String entityType, String entityId, String user,
+                                          VersionableEntityAction action) {
+    VersionInfoEntity versionInfoEntity =
+        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
+    if (versionInfoEntity == null) {
+      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
+    }
+    return getVersionInfo(versionInfoEntity, user, action);
+  }
+
+  @Override
+  public Map<String, VersionInfo> listEntitiesVersionInfo(String entityType, String user,
+                                                          VersionableEntityAction action) {
+    Collection<VersionInfoEntity> versionInfoEntities =
+        versionInfoDao.list(new VersionInfoEntity(entityType, null));
+    Map<String, VersionInfo> activeVersions = new HashMap<>();
+    for (VersionInfoEntity versionInfoEntity : versionInfoEntities) {
+      activeVersions
+          .put(versionInfoEntity.getEntityId(), getVersionInfo(versionInfoEntity, user, action));
+    }
+    return activeVersions;
+  }
+
+  @Override
+  public Map<String, VersionInfo> listDeletedEntitiesVersionInfo(String entityType, String user,
+                                                                 VersionableEntityAction action) {
+    Collection<VersionInfoDeletedEntity> versionInfoDeletedEntities =
+        versionInfoDeletedDao.list(new VersionInfoDeletedEntity(entityType, null));
+    Map<String, VersionInfo> activeVersions = new HashMap<>();
+
+
+    for (VersionInfoDeletedEntity versionInfoDeletedEntity : versionInfoDeletedEntities) {
+      activeVersions.put(versionInfoDeletedEntity.getEntityId(),
+          getVersionInfo(versionInfoDeletedEntity, user, action));
+    }
+    return activeVersions;
+  }
+
+  @Override
+  public List<Version> list(String itemId) {
+
+    List<Version> versions = versionDao.list(itemId);
+    Set<String> versionsNames = versions.stream().map(Version::getName).collect(Collectors.toSet());
+    versions.forEach(version -> {
+      version.setAdditionalInfo(new HashMap<>());
+      versionCalculator.injectAdditionalInfo(version, versionsNames);
+    });
+    return versions;
+  }
+
+  @Override
+  public Version get(String itemId, Version version) {
+    return versionDao.get(itemId, version)
+        .map(retrievedVersion -> getUpdateRetrievedVersion(itemId, retrievedVersion))
+        .orElseGet(() -> getSyncedVersion(itemId, version));
+  }
+
+  private Version getUpdateRetrievedVersion(String itemId, Version version) {
+    if (version.getStatus() == VersionStatus.Certified &&
+        (version.getState().getSynchronizationState() == SynchronizationState.OutOfSync ||
+            version.getState().isDirty())) {
+      forceSync(itemId, version);
+      LOGGER.info("Item Id {}, version Id {}: Force sync is done", itemId, version.getId());
+      version = versionDao.get(itemId, version)
+          .orElseThrow(() -> new IllegalStateException(
+              "Get version after a successful force sync must return the version"));
+    }
+    return version;
+  }
+
+  private Version getSyncedVersion(String itemId, Version version) {
+    sync(itemId, version);
+    LOGGER.info("Item Id {}, version Id {}: First time sync is done", itemId, version.getId());
+    return versionDao.get(itemId, version)
+        .orElseThrow(() -> new IllegalStateException(
+            "Get version after a successful sync must return the version"));
+  }
+
+  @Override
+  public Version create(String itemId, Version version, VersionCreationMethod creationMethod) {
+    String baseVersionName = null;
+    if (version.getBaseId() == null) {
+      version.setDescription("Initial version");
+    } else {
+      baseVersionName = get(itemId, new Version(version.getBaseId())).getName();
+    }
+    String versionName = versionCalculator.calculate(baseVersionName, creationMethod);
+    validateVersionName(itemId, versionName);
+    version.setName(versionName);
+
+    versionDao.create(itemId, version);
+    asdcItemManager.updateVersionStatus(itemId, VersionStatus.Draft, null);
+
+    publish(itemId, version, String.format("Create version: %s", version.getName()));
+    return version;
+  }
+
+  private void validateVersionName(String itemId, String versionName) {
+    if (versionDao.list(itemId).stream()
+        .anyMatch(version -> versionName.equals(version.getName()))) {
+      String errorDescription = String
+          .format("Item %s: create version failed, a version with the name %s already exist",
+              itemId, versionName);
+      throw new CoreException(new ErrorCode.ErrorCodeBuilder()
+          .withCategory(ErrorCategory.APPLICATION)
+          .withId("VERSION_NAME_ALREADY_EXIST")
+          .withMessage(errorDescription)
+          .build());
+    }
+  }
+
+  @Override
+  public void submit(String itemId, Version version, String submitDescription) {
+    version = get(itemId, version);
+
+    validateSubmit(itemId, version);
+
+    version.setStatus(VersionStatus.Certified);
+    versionDao.update(itemId, version);
+
+    publish(itemId, version, submitDescription);
+
+    asdcItemManager.updateVersionStatus(itemId, VersionStatus.Certified, VersionStatus.Draft);
+  }
+
+  private void validateSubmit(String itemId, Version version) {
+    if (version.getStatus() == VersionStatus.Certified) {
+      String errorDescription = String
+          .format("Item %s: submit version failed, version %s is already Certified", itemId,
+              version.getId());
+      throw new CoreException(new ErrorCode.ErrorCodeBuilder()
+          .withCategory(ErrorCategory.APPLICATION)
+          .withId("VERSION_ALREADY_CERTIFIED")
+          .withMessage(errorDescription)
+          .build());
+    }
+  }
+
+  @Override
+  public void publish(String itemId, Version version, String message) {
+    versionDao.publish(itemId, version, message);
+  }
+
+
+  @Override
+  public void sync(String itemId, Version version) {
+    versionDao.sync(itemId, version);
+  }
+
+  @Override
+  public void forceSync(String itemId, Version version) {
+    versionDao.forceSync(itemId, version);
+  }
+
+  @Override
+  public void revert(String itemId, Version version, String revisionId) {
+    versionDao.revert(itemId, version, revisionId);
+  }
+
+  @Override
+  public List<Revision> listRevisions(String itemId, Version version) {
+    return versionDao.listRevisions(itemId, version);
+  }
+
+  private void markAsCheckedOut(VersionInfoEntity versionInfoEntity, String checkingOutUser) {
+    versionInfoEntity.setStatus(VersionStatus.Locked);
+    versionInfoEntity.setCandidate(new UserCandidateVersion(checkingOutUser,
+        versionInfoEntity.getActiveVersion().calculateNextCandidate()));
+  }
+
+  private Version doCheckout(VersionInfoEntity versionInfoEntity, String user) {
+    markAsCheckedOut(versionInfoEntity, user);
+    versionInfoDao.update(versionInfoEntity);
+
+    initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+        versionInfoEntity.getActiveVersion(), versionInfoEntity.getCandidate().getVersion());
+
+    return versionInfoEntity.getCandidate().getVersion();
+  }
+
+  private void doDelete(VersionInfoEntity versionInfoEntity) {
+    VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity();
+    versionInfoDeletedEntity.setStatus(versionInfoEntity.getStatus());
+    versionInfoDeletedEntity.setViewableVersions(versionInfoEntity.getViewableVersions());
+    versionInfoDeletedEntity.setActiveVersion(versionInfoEntity.getActiveVersion());
+    versionInfoDeletedEntity.setCandidate(versionInfoEntity.getCandidate());
+    versionInfoDeletedEntity.setEntityId(versionInfoEntity.getEntityId());
+    versionInfoDeletedEntity.setEntityType(versionInfoEntity.getEntityType());
+    versionInfoDeletedEntity.setLatestFinalVersion(versionInfoEntity.getLatestFinalVersion());
+    versionInfoDeletedDao.create(versionInfoDeletedEntity);
+    versionInfoDao.delete(versionInfoEntity);
+  }
+
+  private void doUndoDelete(VersionInfoDeletedEntity versionInfoDeletedEntity) {
+    VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
+    versionInfoEntity.setStatus(versionInfoDeletedEntity.getStatus());
+    versionInfoEntity.setViewableVersions(versionInfoDeletedEntity.getViewableVersions());
+    versionInfoEntity.setActiveVersion(versionInfoDeletedEntity.getActiveVersion());
+    versionInfoEntity.setCandidate(versionInfoDeletedEntity.getCandidate());
+    versionInfoEntity.setEntityId(versionInfoDeletedEntity.getEntityId());
+    versionInfoEntity.setEntityType(versionInfoDeletedEntity.getEntityType());
+    versionInfoEntity.setLatestFinalVersion(versionInfoDeletedEntity.getLatestFinalVersion());
+    versionInfoDao.create(versionInfoEntity);
+    versionInfoDeletedDao.delete(versionInfoDeletedEntity);
+  }
+
+  private Version doCheckin(VersionInfoEntity versionInfoEntity, String checkinDescription) {
+    UserCandidateVersion userCandidateVersion = versionInfoEntity.getCandidate();
+    versionInfoEntity.setCandidate(null);
+    versionInfoEntity.setActiveVersion(userCandidateVersion.getVersion());
+    versionInfoEntity.getViewableVersions().add(versionInfoEntity.getActiveVersion());
+    versionInfoEntity.setStatus(VersionStatus.Draft);
+
+    closeVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+        versionInfoEntity.getActiveVersion());
+
+    versionInfoDao.update(versionInfoEntity);
+
+    return versionInfoEntity.getActiveVersion();
+  }
+
+  private Version doSubmit(VersionInfoEntity versionInfoEntity, String submittingUser,
+                           String submitDescription) {
+    Version finalVersion = versionInfoEntity.getActiveVersion().calculateNextFinal();
+    initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+        versionInfoEntity.getActiveVersion(), finalVersion);
+    closeVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+        finalVersion);
+
+    Set<Version> viewableVersions = new HashSet<>();
+    for (Version version : versionInfoEntity.getViewableVersions()) {
+      if (version.isFinal()) {
+        viewableVersions.add(version);
+      }
+    }
+    viewableVersions.add(finalVersion);
+    versionInfoEntity.setViewableVersions(viewableVersions);
+    versionInfoEntity.setActiveVersion(finalVersion);
+    versionInfoEntity.setLatestFinalVersion(finalVersion);
+    versionInfoEntity.setStatus(VersionStatus.Certified);
+    versionInfoDao.update(versionInfoEntity);
+
+    return finalVersion;
+  }
+
+  private void initVersionOnEntity(String entityType, String entityId, Version baseVersion,
+                                   Version newVersion) {
+    Set<VersionableEntityMetadata> entityMetadatas = VERSIONABLE_ENTITIES.get(entityType);
+    if (entityMetadatas != null) {
+      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
+        VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
+            .initVersion(entityMetadata, entityId, baseVersion, newVersion);
+      }
+    }
+  }
+
+  private void deleteVersionFromEntity(String entityType, String entityId,
+                                       Version versionToDelete, Version backToVersion) {
+    Set<VersionableEntityMetadata> entityMetadatas = VERSIONABLE_ENTITIES.get(entityType);
+    if (entityMetadatas != null) {
+      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
+        VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
+            .deleteVersion(entityMetadata, entityId, versionToDelete, backToVersion);
+      }
+    }
+  }
+
+  private void closeVersionOnEntity(String entityType, String entityId, Version versionToClose) {
+    Set<VersionableEntityMetadata> entityMetadatas = VERSIONABLE_ENTITIES.get(entityType);
+    if (entityMetadatas != null) {
+      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
+        VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
+            .closeVersion(entityMetadata, entityId, versionToClose);
+      }
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerFactoryImpl.java
new file mode 100644
index 0000000000..090f042027
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerFactoryImpl.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.sdc.itempermissions.PermissionsServicesFactory;
+import org.openecomp.sdc.notification.factories.SubscriptionServiceFactory;
+import org.openecomp.sdc.versioning.AsdcItemManager;
+import org.openecomp.sdc.versioning.AsdcItemManagerFactory;
+import org.openecomp.sdc.versioning.dao.ItemDaoFactory;
+
+public class AsdcItemManagerFactoryImpl extends AsdcItemManagerFactory {
+  private static final AsdcItemManager INSTANCE =
+      new AsdcItemManagerImpl(ItemDaoFactory.getInstance().createInterface(),
+          PermissionsServicesFactory.getInstance().createInterface(),
+          SubscriptionServiceFactory.getInstance().createInterface());
+
+  @Override
+  public AsdcItemManager createInterface() {
+    return INSTANCE;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerImpl.java
new file mode 100644
index 0000000000..82d3ae5a61
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerImpl.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+import org.openecomp.sdc.itempermissions.PermissionsServices;
+import org.openecomp.sdc.notification.services.SubscriptionService;
+import org.openecomp.sdc.versioning.AsdcItemManager;
+import org.openecomp.sdc.versioning.dao.ItemDao;
+import org.openecomp.sdc.versioning.types.Item;
+
+public class AsdcItemManagerImpl extends ItemManagerImpl implements AsdcItemManager {
+  private static final String CREATE_ITEM = "Create_Item";
+
+  private PermissionsServices permissionsServices;
+  private SubscriptionService subscriptionService;
+
+  public AsdcItemManagerImpl(ItemDao itemDao, PermissionsServices permissionsServices,
+                             SubscriptionService subscriptionService) {
+    super(itemDao);
+
+    this.permissionsServices = permissionsServices;
+    this.subscriptionService = subscriptionService;
+  }
+
+  @Override
+  public Item create(Item item) {
+    Item createdItem = super.create(item);
+
+    String userId = SessionContextProviderFactory.getInstance()
+        .createInterface().get().getUser().getUserId();
+    String itemId = createdItem.getId();
+    permissionsServices.execute(itemId, userId, CREATE_ITEM);
+    subscriptionService.subscribe(userId, itemId);
+
+    return createdItem;
+  }
+
+
+  @Override
+  public void updateOwner(String itemId, String owner) {
+    Item item = get(itemId);
+    if (item == null) {
+      return;
+    }
+    item.setOwner(owner);
+    super.update(item);
+  }
+
+  @Override
+  public void delete(Item item) {
+    super.delete(item);
+  }
+
+
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerFactoryImpl.java
index ba5bd07d42..fbbc32e58e 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerFactoryImpl.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerFactoryImpl.java
@@ -1,39 +1,31 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *   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.versioning.impl;
 
-import org.openecomp.sdc.itempermissions.PermissionsServicesFactory;
-import org.openecomp.sdc.notification.factories.SubscriptionServiceFactory;
 import org.openecomp.sdc.versioning.ItemManager;
 import org.openecomp.sdc.versioning.ItemManagerFactory;
 import org.openecomp.sdc.versioning.dao.ItemDaoFactory;
 
 public class ItemManagerFactoryImpl extends ItemManagerFactory {
-  private static final ItemManager INSTANCE =
-      new ItemManagerImpl(ItemDaoFactory.getInstance().createInterface(),
-          PermissionsServicesFactory.getInstance().createInterface(),
-          SubscriptionServiceFactory.getInstance().createInterface());
+  private static final ItemManager instance =
+      new ItemManagerImpl(ItemDaoFactory.getInstance().createInterface());
 
   @Override
   public ItemManager createInterface() {
-    return INSTANCE;
+    return instance;
   }
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerImpl.java
index ba51b17575..dadf456ad4 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerImpl.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerImpl.java
@@ -1,29 +1,37 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package org.openecomp.sdc.versioning.impl;
 
-import org.openecomp.sdc.common.session.SessionContextProviderFactory;
-import org.openecomp.sdc.itempermissions.PermissionsServices;
-import org.openecomp.sdc.notification.services.SubscriptionService;
+import java.util.Collection;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import org.openecomp.sdc.versioning.ItemManager;
 import org.openecomp.sdc.versioning.dao.ItemDao;
 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
 import org.openecomp.sdc.versioning.types.Item;
 
-import java.util.Collection;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
 public class ItemManagerImpl implements ItemManager {
-  private static final String CREATE_ITEM = "Create_Item";
 
   private ItemDao itemDao;
-  private PermissionsServices permissionsServices;
-  private SubscriptionService subscriptionService;
 
-  public ItemManagerImpl(ItemDao itemDao, PermissionsServices permissionsServices,
-                         SubscriptionService subscriptionService) {
+
+  public ItemManagerImpl(ItemDao itemDao) {
     this.itemDao = itemDao;
-    this.permissionsServices = permissionsServices;
-    this.subscriptionService = subscriptionService;
+
   }
 
   @Override
@@ -40,15 +48,7 @@ public class ItemManagerImpl implements ItemManager {
 
   @Override
   public Item create(Item item) {
-    Item createdItem = itemDao.create(item);
-
-    String userId = SessionContextProviderFactory.getInstance()
-        .createInterface().get().getUser().getUserId();
-    String itemId = createdItem.getId();
-    permissionsServices.execute(itemId, userId, CREATE_ITEM);
-    subscriptionService.subscribe(userId, itemId);
-
-    return createdItem;
+    return itemDao.create(item);
   }
 
   @Override
@@ -67,18 +67,23 @@ public class ItemManagerImpl implements ItemManager {
   }
 
   @Override
-  public void updateOwner(String itemId, String owner){
+  public void delete(Item item) {
+    itemDao.delete(item);
+  }
+
+  @Override
+  public void updateName(String itemId, String name) {
     Item item = get(itemId);
     if (item == null) {
       return;
     }
 
-    item.setOwner(owner);
+    item.setName(name);
     itemDao.update(item);
   }
 
   @Override
-  public void delete(Item item) {
-    itemDao.delete(item);
+  public void update(Item item) {
+    itemDao.update(item);
   }
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java
index b4dbcf3a08..83f3d77ae3 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java
@@ -1,21 +1,17 @@
-/*-
- * ============LICENSE_START=======================================================
- * SDC
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *   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.versioning.impl;
@@ -25,19 +21,15 @@ import org.openecomp.sdc.versioning.VersionCalculatorFactory;
 import org.openecomp.sdc.versioning.VersioningManager;
 import org.openecomp.sdc.versioning.VersioningManagerFactory;
 import org.openecomp.sdc.versioning.dao.VersionDaoFactory;
-import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
-import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
 
 public class VersioningManagerFactoryImpl extends VersioningManagerFactory {
-  private static final VersioningManager INSTANCE = new VersioningManagerImpl(
-      VersionInfoDaoFactory.getInstance().createInterface(),
-      VersionInfoDeletedDaoFactory.getInstance().createInterface(),
-      VersionDaoFactory.getInstance().createInterface(),
-      VersionCalculatorFactory.getInstance().createInterface(),
-      ItemManagerFactory.getInstance().createInterface());
+
 
   @Override
   public VersioningManager createInterface() {
-    return INSTANCE;
+    return new VersioningManagerImpl(
+        VersionDaoFactory.getInstance().createInterface(),
+        VersionCalculatorFactory.getInstance().createInterface(),
+        ItemManagerFactory.getInstance().createInterface());
   }
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java
index af63d86b69..091def645d 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java
@@ -1,11 +1,11 @@
 /*
- * Copyright © 2016-2017 European Support Limited
+ * Copyright © 2016-2018 European Support Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *   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,
@@ -16,7 +16,15 @@
 
 package org.openecomp.sdc.versioning.impl;
 
+import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
+import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 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;
@@ -24,364 +32,26 @@ import org.openecomp.sdc.versioning.ItemManager;
 import org.openecomp.sdc.versioning.VersionCalculator;
 import org.openecomp.sdc.versioning.VersioningManager;
 import org.openecomp.sdc.versioning.dao.VersionDao;
-import org.openecomp.sdc.versioning.dao.VersionInfoDao;
-import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
-import org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory;
 import org.openecomp.sdc.versioning.dao.types.Revision;
 import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
-import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
 import org.openecomp.sdc.versioning.dao.types.Version;
-import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
-import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
-import org.openecomp.sdc.versioning.dao.types.VersionStatus;
-import org.openecomp.sdc.versioning.errors.CheckinOnEntityLockedByOtherErrorBuilder;
-import org.openecomp.sdc.versioning.errors.CheckinOnUnlockedEntityErrorBuilder;
-import org.openecomp.sdc.versioning.errors.CheckoutOnLockedEntityErrorBuilder;
-import org.openecomp.sdc.versioning.errors.DeleteOnLockedEntityErrorBuilder;
-import org.openecomp.sdc.versioning.errors.EditOnEntityLockedByOtherErrorBuilder;
-import org.openecomp.sdc.versioning.errors.EditOnUnlockedEntityErrorBuilder;
-import org.openecomp.sdc.versioning.errors.EntityAlreadyExistErrorBuilder;
-import org.openecomp.sdc.versioning.errors.EntityAlreadyFinalizedErrorBuilder;
-import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder;
-import org.openecomp.sdc.versioning.errors.SubmitLockedEntityNotAllowedErrorBuilder;
-import org.openecomp.sdc.versioning.errors.UndoCheckoutOnEntityLockedByOtherErrorBuilder;
-import org.openecomp.sdc.versioning.errors.UndoCheckoutOnUnlockedEntityErrorBuilder;
 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
-import org.openecomp.sdc.versioning.types.VersionInfo;
-import org.openecomp.sdc.versioning.types.VersionableEntityAction;
-import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
-
-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 java.util.stream.Collectors;
 
 public class VersioningManagerImpl implements VersioningManager {
   private static final Logger LOGGER = LoggerFactory.getLogger(VersioningManagerImpl.class);
-  private static final Version INITIAL_ACTIVE_VERSION = new Version(0, 0);
-  private static final Map<String, Set<VersionableEntityMetadata>> VERSIONABLE_ENTITIES =
-      new HashMap<>();
 
-  private final VersionInfoDao versionInfoDao;
-  private final VersionInfoDeletedDao versionInfoDeletedDao;
   private VersionDao versionDao;
   private VersionCalculator versionCalculator;
   private ItemManager itemManager;
 
-  public VersioningManagerImpl(VersionInfoDao versionInfoDao,
-                               VersionInfoDeletedDao versionInfoDeletedDao,
-                               VersionDao versionDao,
+  public VersioningManagerImpl(VersionDao versionDao,
                                VersionCalculator versionCalculator,
-                               ItemManager itemManager) {
-    this.versionInfoDao = versionInfoDao;
-    this.versionInfoDeletedDao = versionInfoDeletedDao;
+      ItemManager itemManager) {
     this.versionDao = versionDao;
     this.versionCalculator = versionCalculator;
     this.itemManager = itemManager;
   }
 
-  private static VersionInfo getVersionInfo(VersionInfoEntity versionInfoEntity, String user,
-                                            VersionableEntityAction action) {
-    return getVersionInfo(versionInfoEntity.getEntityId(),
-        versionInfoEntity.getEntityType(),
-        versionInfoEntity.getActiveVersion(),
-        versionInfoEntity.getCandidate(),
-        versionInfoEntity.getStatus(),
-        versionInfoEntity.getLatestFinalVersion(),
-        versionInfoEntity.getViewableVersions(),
-        action,
-        user);
-  }
-
-  private static VersionInfo getVersionInfo(VersionInfoDeletedEntity versionInfoEntity, String user,
-                                            VersionableEntityAction action) {
-    return getVersionInfo(versionInfoEntity.getEntityId(),
-        versionInfoEntity.getEntityType(),
-        versionInfoEntity.getActiveVersion(),
-        versionInfoEntity.getCandidate(),
-        versionInfoEntity.getStatus(),
-        versionInfoEntity.getLatestFinalVersion(),
-        versionInfoEntity.getViewableVersions(),
-        action,
-        user);
-  }
-
-  private static VersionInfo getVersionInfo(String entityId, String entityType, Version activeVer,
-                                            UserCandidateVersion candidate, VersionStatus status,
-                                            Version latestFinalVersion,
-                                            Set<Version> viewableVersions,
-                                            VersionableEntityAction action, String user) {
-    Version activeVersion;
-
-    if (action == VersionableEntityAction.Write) {
-      if (candidate != null) {
-        if (user.equals(candidate.getUser())) {
-          activeVersion = candidate.getVersion();
-        } else {
-          throw new CoreException(
-              new EditOnEntityLockedByOtherErrorBuilder(entityType, entityId, candidate.getUser())
-                  .build());
-        }
-      } else {
-        throw new CoreException(new EditOnUnlockedEntityErrorBuilder(entityType, entityId).build());
-      }
-    } else {
-      if (candidate != null && user.equals(candidate.getUser())) {
-        activeVersion = candidate.getVersion();
-      } else {
-        activeVersion = activeVer;
-      }
-    }
-
-    VersionInfo versionInfo = new VersionInfo();
-    versionInfo.setStatus(status);
-    activeVersion.setStatus(status);
-    if (latestFinalVersion != null) {
-      latestFinalVersion.setStatus(status);
-    }
-    if (viewableVersions != null) {
-      viewableVersions.forEach(version -> version.setStatus(status));
-    }
-    versionInfo.setActiveVersion(activeVersion);
-    versionInfo.setLatestFinalVersion(latestFinalVersion);
-    versionInfo.setViewableVersions(toSortedList(viewableVersions));
-    versionInfo.setFinalVersions(getFinalVersions(viewableVersions));
-    if (candidate != null) {
-      candidate.getVersion().setStatus(status);
-      versionInfo.setLockingUser(candidate.getUser());
-      if (user.equals(candidate.getUser())) {
-        versionInfo.getViewableVersions().add(candidate.getVersion());
-      }
-    }
-    return versionInfo;
-  }
-
-  private static List<Version> toSortedList(
-      Set<Version> versions) { // changing the Set to List in DB will require migration...
-    return versions.stream().sorted((o1, o2) -> o1.getMajor() > o2.getMajor() ? 1
-        : o1.getMajor() == o2.getMajor() ? (Integer.compare(o1.getMinor(), o2.getMinor())) : -1)
-            .collect(Collectors.toList());
-  }
-
-  private static List<Version> getFinalVersions(Set<Version> versions) {
-    return versions.stream().filter(Version::isFinal).collect(Collectors.toList());
-  }
-
-  @Override
-  public void register(String entityType, VersionableEntityMetadata entityMetadata) {
-    Set<VersionableEntityMetadata> entitiesMetadata =
-        VERSIONABLE_ENTITIES.computeIfAbsent(entityType, k -> new HashSet<>());
-    entitiesMetadata.add(entityMetadata);
-  }
-
-  @Override
-  public Version create(String entityType, String entityId, String user) {
-    VersionInfoEntity
-        versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
-    if (versionInfoEntity != null) {
-      throw new CoreException(new EntityAlreadyExistErrorBuilder(entityType, entityId).build());
-    }
-
-    versionInfoEntity = new VersionInfoEntity(entityType, entityId);
-    versionInfoEntity.setActiveVersion(INITIAL_ACTIVE_VERSION);
-    markAsCheckedOut(versionInfoEntity, user);
-    versionInfoDao.create(versionInfoEntity);
-
-    return versionInfoEntity.getCandidate().getVersion();
-  }
-
-  @Override
-  public void delete(String entityType, String entityId, String user) {
-    VersionInfoEntity versionInfoEntity =
-        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
-    if (versionInfoEntity == null) {
-      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
-    }
-
-    if (versionInfoEntity.getStatus() == VersionStatus.Locked) {
-      throw new CoreException(new DeleteOnLockedEntityErrorBuilder(entityType, entityId,
-              versionInfoEntity.getCandidate().getUser()).build());
-    }
-
-    doDelete(versionInfoEntity);
-  }
-
-  @Override
-  public void undoDelete(String entityType, String entityId, String user) {
-    VersionInfoDeletedEntity versionInfoDeletedEntity =
-        versionInfoDeletedDao.get(new VersionInfoDeletedEntity(entityType, entityId));
-    if (versionInfoDeletedEntity == null) {
-      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
-    }
-
-    doUndoDelete(versionInfoDeletedEntity);
-  }
-
-  @Override
-  public Version checkout(String entityType, String entityId, String user) {
-    VersionInfoEntity versionInfoEntity =
-        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
-    if (versionInfoEntity == null) {
-      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
-    }
-
-    Version checkoutVersion = null;
-    switch (versionInfoEntity.getStatus()) {
-      case Locked:
-        throw new CoreException(new CheckoutOnLockedEntityErrorBuilder(entityType, entityId,
-            versionInfoEntity.getCandidate().getUser()).build());
-      case Certified:
-      case Draft:
-        checkoutVersion = doCheckout(versionInfoEntity, user);
-        break;
-      default:
-        //do nothing
-        break;
-    }
-
-    return checkoutVersion;
-  }
-
-  @Override
-  public Version undoCheckout(String entityType, String entityId, String user) {
-    VersionInfoEntity versionInfoEntity =
-        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
-    if (versionInfoEntity == null) {
-      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
-    }
-
-    Version activeVersion = null;
-    switch (versionInfoEntity.getStatus()) {
-      case Locked:
-        if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
-          throw new CoreException(
-              new UndoCheckoutOnEntityLockedByOtherErrorBuilder(entityType, entityId,
-                  versionInfoEntity.getCandidate().getUser()).build());
-        }
-        activeVersion = undoCheckout(versionInfoEntity);
-        break;
-      case Certified:
-      case Draft:
-        throw new CoreException(
-            new UndoCheckoutOnUnlockedEntityErrorBuilder(entityType, entityId).build());
-      default:
-        //do nothing
-        break;
-    }
-
-    return activeVersion;
-  }
-
-  private Version undoCheckout(VersionInfoEntity versionInfoEntity) {
-    deleteVersionFromEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
-        versionInfoEntity.getCandidate().getVersion(), versionInfoEntity.getActiveVersion());
-
-    versionInfoEntity
-        .setStatus(versionInfoEntity.getActiveVersion().isFinal() ? VersionStatus.Certified
-            : VersionStatus.Draft);
-    versionInfoEntity.setCandidate(null);
-    versionInfoDao.update(versionInfoEntity);
-    return versionInfoEntity.getActiveVersion();
-  }
-
-  @Override
-  public Version checkin(String entityType, String entityId, String user,
-                         String checkinDescription) {
-    VersionInfoEntity versionInfoEntity =
-        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
-    if (versionInfoEntity == null) {
-      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
-    }
-
-    Version checkedInVersion = null;
-    switch (versionInfoEntity.getStatus()) {
-      case Draft:
-      case Certified:
-        throw new CoreException(
-            new CheckinOnUnlockedEntityErrorBuilder(entityType, entityId).build());
-      case Locked:
-        if (!user.equals(versionInfoEntity.getCandidate().getUser())) {
-          throw new CoreException(new CheckinOnEntityLockedByOtherErrorBuilder(entityType, entityId,
-              versionInfoEntity.getCandidate().getUser()).build());
-        }
-        checkedInVersion = doCheckin(versionInfoEntity);
-        break;
-      default:
-        //do nothing
-        break;
-    }
-
-    return checkedInVersion;
-  }
-
-  @Override
-  public Version submit(String entityType, String entityId, String user, String submitDescription) {
-    VersionInfoEntity versionInfoEntity =
-        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
-    if (versionInfoEntity == null) {
-      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
-    }
-
-    Version submitVersion = null;
-    switch (versionInfoEntity.getStatus()) {
-      case Certified:
-        throw new CoreException(
-            new EntityAlreadyFinalizedErrorBuilder(entityType, entityId).build());
-      case Locked:
-        throw new CoreException(new SubmitLockedEntityNotAllowedErrorBuilder(entityType, entityId,
-            versionInfoEntity.getCandidate().getUser()).build());
-      case Draft:
-        submitVersion = doSubmit(versionInfoEntity);
-        break;
-      default:
-        //do nothing
-        break;
-    }
-
-    return submitVersion;
-  }
-
-  @Override
-  public VersionInfo getEntityVersionInfo(String entityType, String entityId, String user,
-                                          VersionableEntityAction action) {
-    VersionInfoEntity versionInfoEntity =
-        versionInfoDao.get(new VersionInfoEntity(entityType, entityId));
-    if (versionInfoEntity == null) {
-      throw new CoreException(new EntityNotExistErrorBuilder(entityType, entityId).build());
-    }
-    return getVersionInfo(versionInfoEntity, user, action);
-  }
-
-  @Override
-  public Map<String, VersionInfo> listEntitiesVersionInfo(String entityType, String user,
-                                                          VersionableEntityAction action) {
-    Collection<VersionInfoEntity> versionInfoEntities =
-        versionInfoDao.list(new VersionInfoEntity(entityType, null));
-    Map<String, VersionInfo> activeVersions = new HashMap<>();
-    for (VersionInfoEntity versionInfoEntity : versionInfoEntities) {
-      activeVersions
-          .put(versionInfoEntity.getEntityId(), getVersionInfo(versionInfoEntity, user, action));
-    }
-    return activeVersions;
-  }
-
-  @Override
-  public Map<String, VersionInfo> listDeletedEntitiesVersionInfo(String entityType, String user,
-                                                                 VersionableEntityAction action) {
-    Collection<VersionInfoDeletedEntity> versionInfoDeletedEntities =
-        versionInfoDeletedDao.list(new VersionInfoDeletedEntity(entityType, null));
-    Map<String, VersionInfo> activeVersions = new HashMap<>();
-
-
-    for (VersionInfoDeletedEntity versionInfoDeletedEntity : versionInfoDeletedEntities) {
-      activeVersions.put(versionInfoDeletedEntity.getEntityId(),
-          getVersionInfo(versionInfoDeletedEntity, user, action));
-    }
-    return activeVersions;
-  }
 
   @Override
   public List<Version> list(String itemId) {
@@ -403,7 +73,7 @@ public class VersioningManagerImpl implements VersioningManager {
   }
 
   private Version getUpdateRetrievedVersion(String itemId, Version version) {
-    if (version.getStatus() == VersionStatus.Certified &&
+    if (version.getStatus() == Certified &&
         (version.getState().getSynchronizationState() == SynchronizationState.OutOfSync ||
             version.getState().isDirty())) {
       forceSync(itemId, version);
@@ -436,7 +106,7 @@ public class VersioningManagerImpl implements VersioningManager {
     version.setName(versionName);
 
     versionDao.create(itemId, version);
-    itemManager.updateVersionStatus(itemId, VersionStatus.Draft, null);
+    itemManager.updateVersionStatus(itemId, Draft, null);
 
     publish(itemId, version, String.format("Create version: %s", version.getName()));
     return version;
@@ -448,6 +118,7 @@ public class VersioningManagerImpl implements VersioningManager {
       String errorDescription = String
           .format("Item %s: create version failed, a version with the name %s already exist",
               itemId, versionName);
+
       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
           .withMessage(errorDescription)
           .build());
@@ -460,20 +131,22 @@ public class VersioningManagerImpl implements VersioningManager {
 
     validateSubmit(itemId, version);
 
-    version.setStatus(VersionStatus.Certified);
+    version.setStatus(Certified);
     versionDao.update(itemId, version);
 
     publish(itemId, version, submitDescription);
 
-    itemManager.updateVersionStatus(itemId, VersionStatus.Certified, VersionStatus.Draft);
+    itemManager.updateVersionStatus(itemId, Certified, Draft);
   }
 
   private void validateSubmit(String itemId, Version version) {
-    if (version.getStatus() == VersionStatus.Certified) {
+    if (version.getStatus() == Certified) {
       String errorDescription = String
           .format("Item %s: submit version failed, version %s is already Certified", itemId,
               version.getId());
       throw new CoreException(new ErrorCode.ErrorCodeBuilder()
+          .withCategory(ErrorCategory.APPLICATION)
+          .withId("VERSION_ALREADY_CERTIFIED")
           .withMessage(errorDescription)
           .build());
     }
@@ -505,115 +178,9 @@ public class VersioningManagerImpl implements VersioningManager {
     return versionDao.listRevisions(itemId, version);
   }
 
-  private void markAsCheckedOut(VersionInfoEntity versionInfoEntity, String checkingOutUser) {
-    versionInfoEntity.setStatus(VersionStatus.Locked);
-    versionInfoEntity.setCandidate(new UserCandidateVersion(checkingOutUser,
-        versionInfoEntity.getActiveVersion().calculateNextCandidate()));
-  }
-
-  private Version doCheckout(VersionInfoEntity versionInfoEntity, String user) {
-    markAsCheckedOut(versionInfoEntity, user);
-    versionInfoDao.update(versionInfoEntity);
-
-    initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
-        versionInfoEntity.getActiveVersion(), versionInfoEntity.getCandidate().getVersion());
-
-    return versionInfoEntity.getCandidate().getVersion();
-  }
-
-  private void doDelete(VersionInfoEntity versionInfoEntity) {
-    VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity();
-    versionInfoDeletedEntity.setStatus(versionInfoEntity.getStatus());
-    versionInfoDeletedEntity.setViewableVersions(versionInfoEntity.getViewableVersions());
-    versionInfoDeletedEntity.setActiveVersion(versionInfoEntity.getActiveVersion());
-    versionInfoDeletedEntity.setCandidate(versionInfoEntity.getCandidate());
-    versionInfoDeletedEntity.setEntityId(versionInfoEntity.getEntityId());
-    versionInfoDeletedEntity.setEntityType(versionInfoEntity.getEntityType());
-    versionInfoDeletedEntity.setLatestFinalVersion(versionInfoEntity.getLatestFinalVersion());
-    versionInfoDeletedDao.create(versionInfoDeletedEntity);
-    versionInfoDao.delete(versionInfoEntity);
-  }
-
-  private void doUndoDelete(VersionInfoDeletedEntity versionInfoDeletedEntity) {
-    VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
-    versionInfoEntity.setStatus(versionInfoDeletedEntity.getStatus());
-    versionInfoEntity.setViewableVersions(versionInfoDeletedEntity.getViewableVersions());
-    versionInfoEntity.setActiveVersion(versionInfoDeletedEntity.getActiveVersion());
-    versionInfoEntity.setCandidate(versionInfoDeletedEntity.getCandidate());
-    versionInfoEntity.setEntityId(versionInfoDeletedEntity.getEntityId());
-    versionInfoEntity.setEntityType(versionInfoDeletedEntity.getEntityType());
-    versionInfoEntity.setLatestFinalVersion(versionInfoDeletedEntity.getLatestFinalVersion());
-    versionInfoDao.create(versionInfoEntity);
-    versionInfoDeletedDao.delete(versionInfoDeletedEntity);
-  }
-
-  private Version doCheckin(VersionInfoEntity versionInfoEntity) {
-    UserCandidateVersion userCandidateVersion = versionInfoEntity.getCandidate();
-    versionInfoEntity.setCandidate(null);
-    versionInfoEntity.setActiveVersion(userCandidateVersion.getVersion());
-    versionInfoEntity.getViewableVersions().add(versionInfoEntity.getActiveVersion());
-    versionInfoEntity.setStatus(VersionStatus.Draft);
-
-    closeVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
-        versionInfoEntity.getActiveVersion());
-
-    versionInfoDao.update(versionInfoEntity);
-
-    return versionInfoEntity.getActiveVersion();
-  }
-
-  private Version doSubmit(VersionInfoEntity versionInfoEntity) {
-    Version finalVersion = versionInfoEntity.getActiveVersion().calculateNextFinal();
-    initVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
-        versionInfoEntity.getActiveVersion(), finalVersion);
-    closeVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
-        finalVersion);
-
-    Set<Version> viewableVersions = new HashSet<>();
-    for (Version version : versionInfoEntity.getViewableVersions()) {
-      if (version.isFinal()) {
-        viewableVersions.add(version);
-      }
-    }
-    viewableVersions.add(finalVersion);
-    versionInfoEntity.setViewableVersions(viewableVersions);
-    versionInfoEntity.setActiveVersion(finalVersion);
-    versionInfoEntity.setLatestFinalVersion(finalVersion);
-    versionInfoEntity.setStatus(VersionStatus.Certified);
-    versionInfoDao.update(versionInfoEntity);
-
-    return finalVersion;
-  }
-
-  private void initVersionOnEntity(String entityType, String entityId, Version baseVersion,
-                                   Version newVersion) {
-    Set<VersionableEntityMetadata> entityMetadatas = VERSIONABLE_ENTITIES.get(entityType);
-    if (entityMetadatas != null) {
-      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
-        VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
-            .initVersion(entityMetadata, entityId, baseVersion, newVersion);
-      }
-    }
-  }
-
-  private void deleteVersionFromEntity(String entityType, String entityId,
-                                       Version versionToDelete, Version backToVersion) {
-    Set<VersionableEntityMetadata> entityMetadatas = VERSIONABLE_ENTITIES.get(entityType);
-    if (entityMetadatas != null) {
-      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
-        VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
-            .deleteVersion(entityMetadata, entityId, versionToDelete, backToVersion);
-      }
-    }
+  @Override
+  public void updateVersion(String itemId, Version version) {
+    versionDao.update(itemId, version);
   }
 
-  private void closeVersionOnEntity(String entityType, String entityId, Version versionToClose) {
-    Set<VersionableEntityMetadata> entityMetadatas = VERSIONABLE_ENTITIES.get(entityType);
-    if (entityMetadatas != null) {
-      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
-        VersionableEntityDaoFactory.getInstance().createInterface(entityMetadata.getStoreType())
-            .closeVersion(entityMetadata, entityId, versionToClose);
-      }
-    }
-  }
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/ItemManagerImplTest.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerImplTest.java
index 95c38e46e4..92d1e7f719 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/ItemManagerImplTest.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/AsdcItemManagerImplTest.java
@@ -25,7 +25,7 @@ import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertNull;
 import static org.testng.Assert.assertTrue;
 
-public class ItemManagerImplTest {
+public class AsdcItemManagerImplTest {
 
   private static final String USER = "user1";
   private static final String ITEM_ID = "item1";
@@ -40,7 +40,7 @@ public class ItemManagerImplTest {
   @Mock
   private SubscriptionService subscriptionService;
   @InjectMocks
-  private ItemManagerImpl itemManager;
+  private AsdcItemManagerImpl itemManager;
 
   @BeforeMethod
   public void setUp() throws Exception {
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/VersioningManagerImplTest.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/VersioningManagerImplTest.java
index 4f8c682c5e..5225f0e644 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/VersioningManagerImplTest.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/VersioningManagerImplTest.java
@@ -20,12 +20,13 @@
 
 package org.openecomp.sdc.versioning.impl;
 
-
 import org.mockito.ArgumentCaptor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.versioning.ActionVersioningManager;
+import org.openecomp.sdc.versioning.AsdcItemManager;
 import org.openecomp.sdc.versioning.ItemManager;
 import org.openecomp.sdc.versioning.VersionCalculator;
 import org.openecomp.sdc.versioning.dao.VersionDao;
@@ -66,7 +67,7 @@ public class VersioningManagerImplTest {
   @Mock
   private VersionCalculator versionCalculatorMock;
   @Mock
-  private ItemManager itemManagerMock;
+  private ItemManager asdcItemManager;
   @InjectMocks
   private VersioningManagerImpl versioningManager;
 
@@ -169,7 +170,7 @@ public class VersioningManagerImplTest {
     Assert.assertEquals(version.getName(), versionName);
 
     verify(versionDaoMock).create(ITEM_ID, requestedVersion);
-    verify(itemManagerMock).updateVersionStatus(ITEM_ID, Draft, null);
+    verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null);
     verify(versionDaoMock)
         .publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: versionName"));
   }
@@ -198,7 +199,7 @@ public class VersioningManagerImplTest {
     Assert.assertEquals(version.getName(), versionName);
 
     verify(versionDaoMock).create(ITEM_ID, requestedVersion);
-    verify(itemManagerMock).updateVersionStatus(ITEM_ID, Draft, null);
+    verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null);
     verify(versionDaoMock).publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: 4.0"));
   }
 
@@ -250,7 +251,7 @@ public class VersioningManagerImplTest {
     verify(versionDaoMock).update(eq(ITEM_ID), versionArgumentCaptor.capture());
     Assert.assertEquals(Certified, versionArgumentCaptor.getValue().getStatus());
     verify(versionDaoMock).publish(ITEM_ID, version, submitDescription);
-    verify(itemManagerMock).updateVersionStatus(ITEM_ID, Certified, Draft);
+    verify(asdcItemManager).updateVersionStatus(ITEM_ID, Certified, Draft);
   }
 
   @Test