push addional code

Change-Id: Ia427bb3460cda3a896f8faced2de69eaf3807b74
Signed-off-by: Michael Lando <ml636r@att.com>

11 files changed, 1357 insertions, 0 deletions

diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryCassandraDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryCassandraDaoImpl.java
new file mode 100644
index 0000000000..a50a8b7beb
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryCassandraDaoImpl.java
@@ -0,0 +1,69 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+import com.datastax.driver.core.UDTValue;
+import com.datastax.driver.mapping.Mapper;
+import com.datastax.driver.mapping.Result;
+import com.datastax.driver.mapping.UDTMapper;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+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.VersionHistoryDao;
+import org.openecomp.sdc.versioning.dao.types.VersionHistoryEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionableEntityId;
+
+import java.util.Collection;
+
+public class VersionHistoryCassandraDaoImpl extends CassandraBaseDao<VersionHistoryEntity>
+    implements VersionHistoryDao {
+
+  private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+  private static Mapper<VersionHistoryEntity> mapper =
+      noSqlDb.getMappingManager().mapper(VersionHistoryEntity.class);
+  private static VersionHistoryAccessor accessor =
+      noSqlDb.getMappingManager().createAccessor(VersionHistoryAccessor.class);
+  private static UDTMapper<VersionableEntityId> versionedEntityIdMapper =
+      noSqlDb.getMappingManager().udtMapper(VersionableEntityId.class);
+
+  @Override
+  protected Mapper<VersionHistoryEntity> getMapper() {
+    return mapper;
+  }
+
+  @Override
+  protected Object[] getKeys(VersionHistoryEntity entity) {
+    return new Object[]{versionedEntityIdMapper.toUDT(entity.getEntityId())};
+  }
+
+  @Override
+  public Collection<VersionHistoryEntity> list(VersionHistoryEntity entity) {
+    return accessor.getAll(versionedEntityIdMapper.toUDT(entity.getEntityId())).all();
+  }
+
+  @Accessor
+  interface VersionHistoryAccessor {
+    @Query("select * from version_history where entity_id=?")
+    Result<VersionHistoryEntity> getAll(UDTValue entityId);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryDaoFactoryImpl.java
new file mode 100644
index 0000000000..ac1c7e9634
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionHistoryDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+import org.openecomp.sdc.versioning.dao.VersionHistoryDao;
+import org.openecomp.sdc.versioning.dao.VersionHistoryDaoFactory;
+
+public class VersionHistoryDaoFactoryImpl extends VersionHistoryDaoFactory {
+  private static final VersionHistoryDao INSTANCE = new VersionHistoryCassandraDaoImpl();
+
+  @Override
+  public VersionHistoryDao createInterface() {
+    return INSTANCE;
+  }
+}
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
new file mode 100644
index 0000000000..46c6a9d795
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+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();
+
+  @Override
+  public VersionInfoDao createInterface() {
+    return INSTANCE;
+  }
+}
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
new file mode 100644
index 0000000000..a45c211f94
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDaoImpl.java
@@ -0,0 +1,66 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+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 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 static UDTMapper<VersionableEntityId> versionedEntityIdMapper = noSqlDb
+  //.getMappingManager().udtMapper(VersionableEntityId.class);
+
+  @Override
+  protected Mapper<VersionInfoEntity> getMapper() {
+    return mapper;
+  }
+
+  @Override
+  protected Object[] getKeys(VersionInfoEntity entity) {
+    return new Object[]{entity.getEntityType(), entity.getEntityId()};
+  }
+
+  @Override
+  public Collection<VersionInfoEntity> list(VersionInfoEntity entity) {
+    return accessor.getAll(entity.getEntityType()).all();
+  }
+
+  @Accessor
+  interface VersionInfoAccessor {
+    @Query("select * from version_info where entity_type=?")
+    Result<VersionInfoEntity> getAll(String entityType);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoFactoryImpl.java
new file mode 100644
index 0000000000..9163018a85
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoFactoryImpl.java
@@ -0,0 +1,34 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+
+public class VersionInfoDeletedDaoFactoryImpl extends VersionInfoDeletedDaoFactory {
+  private static VersionInfoDeletedDao INSTANCE = new VersionInfoDeletedDaoImpl();
+
+  @Override
+  public VersionInfoDeletedDao createInterface() {
+    return INSTANCE;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoImpl.java
new file mode 100644
index 0000000000..82e4edcd80
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionInfoDeletedDaoImpl.java
@@ -0,0 +1,65 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+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 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.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
+
+import java.util.Collection;
+
+public class VersionInfoDeletedDaoImpl extends CassandraBaseDao<VersionInfoDeletedEntity>
+    implements VersionInfoDeletedDao {
+
+  private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+  private static Mapper<VersionInfoDeletedEntity> mapper =
+      noSqlDb.getMappingManager().mapper(VersionInfoDeletedEntity.class);
+  private static VersionInfoAccessor accessor =
+      noSqlDb.getMappingManager().createAccessor(VersionInfoAccessor.class);
+
+
+  @Override
+  protected Mapper<VersionInfoDeletedEntity> getMapper() {
+    return mapper;
+  }
+
+  @Override
+  protected Object[] getKeys(VersionInfoDeletedEntity entity) {
+    return new Object[]{entity.getEntityType(), entity.getEntityId()};
+  }
+
+  @Override
+  public Collection<VersionInfoDeletedEntity> list(VersionInfoDeletedEntity entity) {
+    return accessor.getAll(entity.getEntityType()).all();
+  }
+
+  @Accessor
+  interface VersionInfoAccessor {
+    @Query("select * from version_info_deleted where entity_type=?")
+    Result<VersionInfoDeletedEntity> getAll(String entityType);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoCassandraImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoCassandraImpl.java
new file mode 100644
index 0000000000..f02ea89e34
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoCassandraImpl.java
@@ -0,0 +1,159 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+import com.datastax.driver.core.ColumnDefinitions;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.mapping.UDTMapper;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.core.util.UniqueValueUtil;
+import org.openecomp.core.utilities.CommonMethods;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDao;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.types.UniqueValueMetadata;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+class VersionableEntityDaoCassandraImpl implements VersionableEntityDao {
+
+  private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+  private static org.slf4j.Logger Logger =
+      LoggerFactory.getLogger(VersionableEntityDaoCassandraImpl.class);
+  private static UDTMapper<Version> versionMapper =
+      noSqlDb.getMappingManager().udtMapper(Version.class);
+
+  private static String commaSeparatedQuestionMarks(int size) {
+    StringBuilder sb = new StringBuilder(size * 2 - 1);
+    for (int i = 0; i < size; i++) {
+      if (i > 0) {
+        sb.append(',');
+      }
+      sb.append('?');
+    }
+    return sb.toString();
+
+  }
+
+  @Override
+  public void initVersion(VersionableEntityMetadata metadata, String entityId, Version baseVersion,
+                          Version newVersion) {
+    ResultSet rows = loadVersionRows(metadata, entityId, baseVersion);
+    List<String> columnNames =
+        rows.getColumnDefinitions().asList().stream().map(ColumnDefinitions.Definition::getName)
+            .collect(Collectors.toList());
+
+    String insertCql = String.format("insert into %s (%s) values (%s)", metadata.getName(),
+        CommonMethods.listToSeparatedString(columnNames, ','),
+        commaSeparatedQuestionMarks(columnNames.size()));
+    Logger.debug("insertCql", insertCql);
+
+    for (Row row : rows) {
+      List<Object> columnValues = new ArrayList<>();
+      Map<String, Object> columnNameToValue = new HashMap<>();
+
+      for (String columnName : columnNames) {
+        if (metadata.getVersionIdentifierName().equals(columnName)) {
+          columnValues.add(versionMapper.toUDT(newVersion));
+          columnNameToValue.put(columnName, newVersion.toString());
+        } else {
+          Object value = row.getObject(columnName);
+          columnValues.add(value);
+          columnNameToValue.put(columnName, value);
+        }
+      }
+
+      initRowUniqueValues(metadata.getUniqueValuesMetadata(), columnNameToValue);
+
+      noSqlDb.execute(insertCql, columnValues.toArray());
+    }
+  }
+
+  private ResultSet loadVersionRows(VersionableEntityMetadata metadata, String entityId,
+                                    Version version) {
+    String selectCql = String.format("select * from %s where %s=? and %s=?", metadata.getName(),
+        metadata.getIdentifierName(), metadata.getVersionIdentifierName());
+    Logger.debug("selectCql", selectCql);
+    Logger.debug("entityId", entityId);
+    Logger.debug("version", version);
+
+    return noSqlDb.execute(selectCql, entityId, versionMapper.toUDT(version));
+  }
+
+  @Override
+  public void deleteVersion(VersionableEntityMetadata metadata, String entityId,
+                            Version versionToDelete) {
+    deleteRowsUniqueValues(metadata, entityId, versionToDelete);
+
+    String deleteCql = String.format("delete from %s where %s=? and %s=?", metadata.getName(),
+        metadata.getIdentifierName(), metadata.getVersionIdentifierName());
+    noSqlDb.execute(deleteCql, entityId, versionMapper.toUDT(versionToDelete));
+  }
+
+  private void initRowUniqueValues(List<UniqueValueMetadata> metadata,
+                                   Map<String, Object> columnNameToValue) {
+    for (UniqueValueMetadata uniqueMetadata : metadata) {
+      List<String> uniqueValueCombination = uniqueMetadata.getUniqueConstraintIdentifiers().stream()
+          .map(colName -> (String) columnNameToValue.get(colName)).collect(Collectors.toList());
+      UniqueValueUtil.createUniqueValue(uniqueMetadata.getType(),
+          uniqueValueCombination.toArray(new String[uniqueValueCombination.size()]));
+    }
+  }
+
+  private void deleteRowUniqueValues(List<UniqueValueMetadata> metadata,
+                                     Map<String, Object> columnNameToValue) {
+    for (UniqueValueMetadata uniqueMetadata : metadata) {
+      List<String> uniqueValueCombination = uniqueMetadata.getUniqueConstraintIdentifiers().stream()
+          .map(colName -> (String) columnNameToValue.get(colName)).collect(Collectors.toList());
+      UniqueValueUtil.deleteUniqueValue(uniqueMetadata.getType(),
+          uniqueValueCombination.toArray(new String[uniqueValueCombination.size()]));
+    }
+  }
+
+  private void deleteRowsUniqueValues(VersionableEntityMetadata metadata, String entityId,
+                                      Version version) {
+    if (metadata.getUniqueValuesMetadata().isEmpty()) {
+      return;
+    }
+    ResultSet rows = loadVersionRows(metadata, entityId, version);
+    List<String> columnNames =
+        rows.getColumnDefinitions().asList().stream().map(ColumnDefinitions.Definition::getName)
+            .collect(Collectors.toList());
+
+    for (Row row : rows) {
+      Map<String, Object> columnNameToValue =
+          columnNames.stream().filter(name -> row.getObject(name) != null).collect(Collectors
+              .toMap(Function.identity(),
+                  columnName -> metadata.getVersionIdentifierName().equals(columnName) ? version
+                      .toString() : row.getObject(columnName)));
+      deleteRowUniqueValues(metadata.getUniqueValuesMetadata(), columnNameToValue);
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoFactoryImpl.java
new file mode 100644
index 0000000000..8ec0814fc9
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionableEntityDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao.impl;
+
+import org.openecomp.sdc.versioning.dao.VersionableEntityDao;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory;
+
+public class VersionableEntityDaoFactoryImpl extends VersionableEntityDaoFactory {
+  private static VersionableEntityDao INSTANCE = new VersionableEntityDaoCassandraImpl();
+
+  @Override
+  public VersionableEntityDao 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/VersioningManagerFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java
new file mode 100644
index 0000000000..f7065cfda4
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+
+public class VersioningManagerFactoryImpl extends VersioningManagerFactory {
+  private static final VersioningManager INSTANCE = new VersioningManagerImpl();
+
+  @Override
+  public VersioningManager 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/VersioningManagerImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java
new file mode 100644
index 0000000000..6aa2a9f63c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersioningManagerImpl.java
@@ -0,0 +1,468 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDao;
+import org.openecomp.sdc.versioning.dao.VersionableEntityDaoFactory;
+import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionHistoryEntity;
+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.dao.types.VersionType;
+import org.openecomp.sdc.versioning.dao.types.VersionableEntityId;
+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.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 Version INITIAL_ACTIVE_VERSION = new Version(0, 0);
+  private static VersionInfoDao versionInfoDao =
+      VersionInfoDaoFactory.getInstance().createInterface();
+  private static VersionInfoDeletedDao versionInfoDeletedDao =
+      VersionInfoDeletedDaoFactory.getInstance().createInterface();
+  private static VersionableEntityDao versionableEntityDao =
+      VersionableEntityDaoFactory.getInstance().createInterface();
+
+  private static Map<String, Set<VersionableEntityMetadata>> versionableEntities = new HashMap<>();
+
+  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.setActiveVersion(activeVersion);
+    versionInfo.setLatestFinalVersion(latestFinalVersion);
+    versionInfo.setViewableVersions(toSortedList(viewableVersions));
+    versionInfo.setFinalVersions(getFinalVersions(viewableVersions));
+    versionInfo.setStatus(status);
+    if (candidate != null) {
+      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) -> {
+      return 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 -> version.isFinal()).collect(Collectors.toList());
+  }
+
+  @Override
+  public void register(String entityType, VersionableEntityMetadata entityMetadata) {
+    Set<VersionableEntityMetadata> entitiesMetadata = versionableEntities.get(entityType);
+    if (entitiesMetadata == null) {
+      entitiesMetadata = new HashSet<>();
+      versionableEntities.put(entityType, entitiesMetadata);
+    }
+    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 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 Final:
+      case Available:
+        checkoutVersion = doCheckout(versionInfoEntity, user);
+        break;
+      default:
+    }
+    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 Final:
+      case Available:
+        throw new CoreException(
+            new UndoCheckoutOnUnlockedEntityErrorBuilder(entityType, entityId).build());
+      default:
+    }
+    return activeVersion;
+  }
+
+  private Version undoCheckout(VersionInfoEntity versionInfoEntity) {
+    deleteVersionFromEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
+        versionInfoEntity.getCandidate().getVersion());
+
+    versionInfoEntity.setStatus(versionInfoEntity.getActiveVersion().isFinal() ? VersionStatus.Final
+        : VersionStatus.Available);
+    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 Available:
+      case Final:
+        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:
+    }
+    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 Final:
+        throw new CoreException(
+            new EntityAlreadyFinalizedErrorBuilder(entityType, entityId).build());
+      case Locked:
+        throw new CoreException(new SubmitLockedEntityNotAllowedErrorBuilder(entityType, entityId,
+            versionInfoEntity.getCandidate().getUser()).build());
+      case Available:
+        submitVersion = doSubmit(versionInfoEntity, user, submitDescription);
+        break;
+      default:
+    }
+    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 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:
+    }
+
+    doDelete(versionInfoEntity, user);
+  }
+
+  @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, user);
+  }
+
+  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, String user) {
+
+    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, String user) {
+
+    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.Available);
+    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);
+
+    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.Final);
+    versionInfoDao.update(versionInfoEntity);
+
+    return finalVersion;
+  }
+
+  private void createVersionHistory(VersionableEntityId entityId, Version version, String user,
+                                    String description, VersionType type) {
+    VersionHistoryEntity versionHistory = new VersionHistoryEntity(entityId);
+    versionHistory.setVersion(version);
+    versionHistory.setUser(user);
+    versionHistory.setDescription(description);
+    versionHistory.setType(type);
+  }
+
+  private void initVersionOnEntity(String entityType, String entityId, Version baseVersion,
+                                   Version newVersion) {
+    Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
+    if (entityMetadatas != null) {
+      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
+        versionableEntityDao.initVersion(entityMetadata, entityId, baseVersion, newVersion);
+      }
+    }
+  }
+
+  private void deleteVersionFromEntity(String entityType, String entityId,
+                                       Version versionToDelete) {
+    Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
+    if (entityMetadatas != null) {
+      for (VersionableEntityMetadata entityMetadata : entityMetadatas) {
+        versionableEntityDao.deleteVersion(entityMetadata, entityId, versionToDelete);
+      }
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java
new file mode 100644
index 0000000000..3695f9ef2d
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java
@@ -0,0 +1,364 @@
+package org.openecomp.sdc.versioning;
+
+
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+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.types.VersionInfo;
+import org.openecomp.sdc.versioning.types.VersionableEntityAction;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.mapping.UDTMapper;
+
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class VersioningManagerTest {
+  private static final VersioningManager versioningManager =
+      VersioningManagerFactory.getInstance().createInterface();
+  private static final VersionInfoDao versionInfoDao =
+      VersionInfoDaoFactory.getInstance().createInterface();
+  private static final VersionInfoDeletedDao versionInfoDeletedDao =
+      VersionInfoDeletedDaoFactory.getInstance().createInterface();
+  private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+  private static final String USR1 = "usr1";
+  private static final String USR2 = "usr2";
+  private static final String USR3 = "usr3";
+  private static final String TYPE1 = "Type1";
+  private static final String TYPE2 = "Type2";
+  private static final String ID1 = "Id1";
+  private static final String ID2 = "Id2";
+  private static final String ID3 = "Id3";
+  private static final String TYPE1_TABLE_NAME = "vendor_license_model";
+  private static final String TYPE1_ID_NAME = "vlm_id";
+  private static final String TYPE1_VERSION_NAME = "version";
+  private static final String TYPE2_TABLE_NAME = "feature_group";
+  private static final String TYPE2_ID_NAME = "vlm_id";
+  private static final String TYPE2_VERSION_NAME = "version";
+  private static final Version VERSION01 = new Version(0, 1);
+  private static final Version VERSION02 = new Version(0, 2);
+  private static final Version VERSION10 = new Version(1, 0);
+  private static final Version VERSION11 = new Version(1, 1);
+  private static UDTMapper<Version> versionMapper =
+      noSqlDb.getMappingManager().udtMapper(Version.class);
+  private static Set<Version> expectedViewableVersionsType1Id1 = new HashSet<>();
+
+  private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType,
+                                              String entityId, Version activeVersion,
+                                              Version candidateVersion, String candidateUser,
+                                              VersionStatus status, Set<Version> viewbleVersions,
+                                              Version latestFinalVersion) {
+    Assert.assertNotNull(actual);
+    Assert.assertEquals(actual.getEntityType(), entityType);
+    Assert.assertEquals(actual.getEntityId(), entityId);
+    Assert.assertEquals(actual.getActiveVersion(), activeVersion);
+    if (candidateVersion != null && candidateUser != null) {
+      Assert.assertEquals(actual.getCandidate().getVersion(), candidateVersion);
+      Assert.assertEquals(actual.getCandidate().getUser(), candidateUser);
+    } else {
+      Assert.assertNull(actual.getCandidate());
+    }
+    Assert.assertEquals(actual.getStatus(), status);
+    Assert.assertEquals(actual.getViewableVersions().size(), viewbleVersions.size());
+    Assert.assertEquals(actual.getViewableVersions(), viewbleVersions);
+    Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
+  }
+
+  private static void assretVersionInfo(VersionInfo actual, Version activeVersion,
+                                        VersionStatus status, String lockingUser,
+                                        Set<Version> viewableVersions, Version latestFinalVersion) {
+    Assert.assertNotNull(actual);
+    Assert.assertEquals(actual.getActiveVersion(), activeVersion);
+    Assert.assertEquals(actual.getStatus(), status);
+    Assert.assertEquals(actual.getLockingUser(), lockingUser);
+    Assert.assertEquals(actual.getViewableVersions().size(), viewableVersions.size());
+    Assert.assertEquals(actual.getViewableVersions(), viewableVersions);
+    Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
+  }
+
+//  @BeforeClass
+  private void init() {
+    versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID1));
+    versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID2));
+    versionInfoDao.delete(new VersionInfoEntity(TYPE2, ID3));
+    String deleteFromType1 = String
+        .format("delete from %s where %s=? and %s=?", TYPE1_TABLE_NAME, TYPE1_ID_NAME,
+            TYPE1_VERSION_NAME);
+    noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION01));
+    noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION02));
+    noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION11));
+
+    versioningManager.register(TYPE1,
+        new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME));
+    versioningManager.register(TYPE2,
+        new VersionableEntityMetadata(TYPE2_TABLE_NAME, TYPE2_ID_NAME, TYPE2_VERSION_NAME));
+  }
+
+//  @Test
+  public void createTest() {
+    Version version = versioningManager.create(TYPE1, ID1, USR1);
+    createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+        version);
+
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1,
+        VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
+  }
+
+//  @Test(dependsOnMethods = "createTest")
+  public void checkinTest() {
+    Version version = versioningManager.checkin(TYPE1, ID1, USR1, "checkin 0.1");
+    Assert.assertEquals(version, VERSION01);
+
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    expectedViewableVersionsType1Id1.add(VERSION01);
+    assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
+        VersionStatus.Available, expectedViewableVersionsType1Id1, null);
+  }
+
+//  @Test(dependsOnMethods = "checkinTest")
+  public void getVersionInfoForReadOnAvailableTest() {
+    VersionInfo versionInfo =
+        versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
+    assretVersionInfo(versionInfo, VERSION01, VersionStatus.Available, null,
+        expectedViewableVersionsType1Id1, null);
+  }
+
+//  @Test(dependsOnMethods = "getVersionInfoForReadOnAvailableTest",
+//      expectedExceptions = CoreException.class)
+  public void getVersionInfoForWriteOnAvailableTest() {
+    versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write);
+  }
+
+//  @Test(dependsOnMethods = "getVersionInfoForWriteOnAvailableTest",
+//      expectedExceptions = CoreException.class)
+  public void checkinOnAvailableTest() {
+    versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin");
+  }
+
+//  @Test(dependsOnMethods = "checkinOnAvailableTest", expectedExceptions = CoreException.class)
+  public void undoCheckoutOnAvailableTest() {
+    versioningManager.undoCheckout(TYPE1, ID1, USR1);
+  }
+
+//  @Test(dependsOnMethods = "undoCheckoutOnAvailableTest")
+  public void checkoutTest() {
+    Version version = versioningManager.checkout(TYPE1, ID1, USR2);
+    Assert.assertEquals(version, VERSION02);
+
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR2,
+        VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
+
+    ResultSet results =
+        loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+            VERSION02);
+    Assert.assertTrue(results.iterator().hasNext());
+  }
+
+//  @Test(dependsOnMethods = "checkoutTest")
+  public void getVersionInfoForReadOnLockedSameUserTest() {
+    VersionInfo versionInfo =
+        versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
+    Set<Version> expectedViewableVersions = new HashSet<>();
+    expectedViewableVersions.addAll(expectedViewableVersionsType1Id1);
+    expectedViewableVersions.add(VERSION02);
+    assretVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR2, expectedViewableVersions,
+        null);
+  }
+
+//  @Test(dependsOnMethods = "getVersionInfoForReadOnLockedSameUserTest")
+  public void getVersionInfoForReadOnLockedOtherUserTest() {
+    VersionInfo entityVersionInfo =
+        versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
+    Assert.assertEquals(entityVersionInfo.getActiveVersion(), VERSION01);
+  }
+
+//  @Test(dependsOnMethods = "getVersionInfoForReadOnLockedOtherUserTest",
+//      expectedExceptions = CoreException.class)
+  public void getVersionInfoForWriteOnLockedOtherUserTest() {
+    versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write)
+        .getActiveVersion();
+  }
+
+//  @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedOtherUserTest")
+  public void getVersionInfoForWriteOnLockedSameUserTest() {
+    Version activeVersion =
+        versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write)
+            .getActiveVersion();
+    Assert.assertEquals(activeVersion, VERSION02);
+  }
+
+//  @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedSameUserTest",
+//      expectedExceptions = CoreException.class)
+  public void checkoutOnLockedSameUserTest() {
+    versioningManager.checkout(TYPE1, ID1, USR2);
+  }
+
+//  @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
+  public void checkoutOnLockedOtherUserTest() {
+    versioningManager.checkout(TYPE1, ID1, USR1);
+  }
+
+//  @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
+  public void undoCheckoutOnLockedOtherUserTest() {
+    versioningManager.undoCheckout(TYPE1, ID1, USR1);
+  }
+
+//  @Test(dependsOnMethods = "undoCheckoutOnLockedOtherUserTest",
+//      expectedExceptions = CoreException.class)
+  public void submitOnLockedTest() {
+    versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
+  }
+
+//  @Test(dependsOnMethods = "submitOnLockedTest")
+  public void undoCheckoutTest() {
+    Version version = versioningManager.undoCheckout(TYPE1, ID1, USR2);
+    Assert.assertEquals(version, VERSION01);
+
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
+        VersionStatus.Available, expectedViewableVersionsType1Id1, null);
+
+    ResultSet results =
+        loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+            VERSION02);
+    Assert.assertFalse(results.iterator().hasNext());
+  }
+
+//  @Test(dependsOnMethods = "undoCheckoutTest")
+  public void submitTest() {
+    Version version = versioningManager.submit(TYPE1, ID1, USR3, "submit msg");
+    Assert.assertEquals(version, VERSION10);
+    expectedViewableVersionsType1Id1 = new HashSet<>();
+    expectedViewableVersionsType1Id1.add(version);
+
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, null, null,
+        VersionStatus.Final, expectedViewableVersionsType1Id1, VERSION10);
+
+    ResultSet results =
+        loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+            VERSION10);
+    Assert.assertTrue(results.iterator().hasNext());
+  }
+
+//  @Test(dependsOnMethods = "submitTest", expectedExceptions = CoreException.class)
+  public void checkinOnFinalizedTest() {
+    versioningManager.checkin(TYPE1, ID1, USR2, "failed checkin");
+  }
+
+//  @Test(dependsOnMethods = "checkinOnFinalizedTest", expectedExceptions = CoreException.class)
+  public void undoCheckouOnFinalizedTest() {
+    versioningManager.undoCheckout(TYPE1, ID1, USR2);
+  }
+
+//  @Test(dependsOnMethods = "undoCheckouOnFinalizedTest", expectedExceptions = CoreException.class)
+  public void submitOnFinalizedTest() {
+    versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
+  }
+
+//  @Test(dependsOnMethods = "submitOnFinalizedTest")
+  public void checkoutOnFinalizedTest() {
+    Version version = versioningManager.checkout(TYPE1, ID1, USR3);
+    Assert.assertEquals(version, VERSION11);
+
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR3,
+        VersionStatus.Locked, expectedViewableVersionsType1Id1, VERSION10);
+
+    ResultSet results =
+        loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
+            VERSION11);
+    Assert.assertTrue(results.iterator().hasNext());
+  }
+
+//  @Test(dependsOnMethods = "checkoutOnFinalizedTest")
+  public void viewableVersionsTest() {
+    versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.1");
+    versioningManager.checkout(TYPE1, ID1, USR3);
+    versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.2");
+    versioningManager.submit(TYPE1, ID1, USR3, "submit in 2.0");
+    versioningManager.checkout(TYPE1, ID1, USR3);
+    versioningManager.checkin(TYPE1, ID1, USR3, "check in 2.1");
+    versioningManager.submit(TYPE1, ID1, USR3, "submit in 3.0");
+    versioningManager.checkout(TYPE1, ID1, USR3);
+    versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.1");
+    versioningManager.checkout(TYPE1, ID1, USR3);
+    versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.2");
+    versioningManager.checkout(TYPE1, ID1, USR2);
+
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    HashSet<Version> expectedViewableVersions = new HashSet<>();
+    expectedViewableVersions.add(VERSION10);
+    expectedViewableVersions.add(new Version(2, 0));
+    expectedViewableVersions.add(new Version(3, 0));
+    expectedViewableVersions.add(new Version(3, 1));
+    expectedViewableVersions.add(new Version(3, 2));
+    assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(3, 2), new Version(3, 3),
+        USR2, VersionStatus.Locked, expectedViewableVersions, new Version(3, 0));
+  }
+
+//  @Test(dependsOnMethods = "viewableVersionsTest")
+  public void listActiveVersionsTest() {
+    versioningManager.create(TYPE1, ID2, USR3);
+    versioningManager.checkin(TYPE1, ID2, USR3, "check in 0.1");
+
+    versioningManager.create(TYPE2, ID3, USR3);
+    versioningManager.checkin(TYPE2, ID3, USR3, "check in 0.1");
+
+    Map<String, VersionInfo> idToVersionInfo =
+        versioningManager.listEntitiesVersionInfo(TYPE1, USR2, VersionableEntityAction.Read);
+    Assert.assertEquals(idToVersionInfo.size(), 2);
+    Assert.assertEquals(idToVersionInfo.get(ID1).getActiveVersion(), new Version(3, 3));
+    Assert.assertEquals(idToVersionInfo.get(ID2).getActiveVersion(), VERSION01);
+  }
+
+//  @Test(dependsOnMethods = "listActiveVersionsTest")
+  public void deleteTest() {
+    versioningManager.checkin(TYPE1, ID1, USR2, "check in for delete");
+    versioningManager.delete(TYPE1, ID1, USR1);
+
+    VersionInfoDeletedEntity versionInfoDeletedEntity =
+        versionInfoDeletedDao.get(new VersionInfoDeletedEntity(TYPE1, ID1));
+    Assert.assertNotNull(versionInfoDeletedEntity);
+
+    Map<String, VersionInfo> entitiesInfoMap =
+        versioningManager.listDeletedEntitiesVersionInfo(TYPE1, USR2, null);
+    Assert.assertEquals(entitiesInfoMap.size(), 1);
+    VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    Assert.assertNull(versionInfoEntity);
+    versioningManager.undoDelete(TYPE1, ID1, USR1);
+    versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
+    Assert.assertNotNull(versionInfoEntity);
+
+
+  }
+
+  private void createVersionableEntityRecord(String tableName, String idName, String versionName,
+                                             String id, Version version) {
+    noSqlDb.execute(
+        String.format("insert into %s (%s,%s) values (?,?)", tableName, idName, versionName), id,
+        versionMapper.toUDT(version));
+  }
+
+  private ResultSet loadVersionableEntityRecord(String tableName, String idName, String versionName,
+                                                String id, Version version) {
+    return noSqlDb.execute(
+        String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id,
+        versionMapper.toUDT(version));
+  }
+}