Add collaboration feature

Issue-ID: SDC-767 Change-Id: I14fb4c1f54086ed03a56a7ff7fab9ecd40381795 Signed-off-by: talig <talig@amdocs.com>
author: talig <talig@amdocs.com> 2017-12-20 14:30:43 +0200
committer: Vitaly Emporopulo <Vitaliy.Emporopulo@amdocs.com> 2017-12-21 11:12:33 +0000
commit: 8e9c0653dd6c6862123c9609ae34e1206d86456e (patch)
tree: 5eeef00ec0677133baa439ca8d7ffd7aca4804b6 /openecomp-be/lib/openecomp-sdc-versioning-lib
parent: 785ebcc95de3e064e843bec04ba7a209d854fc7c (diff)
42 files changed, 2321 insertions, 101 deletions
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/pom.xml b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/pom.xml
index d11362c3a3..dcf2c6a10d 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/pom.xml
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/pom.xml
@@ -15,6 +15,21 @@
     <dependencies>
         <dependency>
             <groupId>org.openecomp.sdc.core</groupId>
+            <artifactId>openecomp-session-lib</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-item-permissions-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-item-permissions-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc.core</groupId>
             <artifactId>openecomp-facade-core</artifactId>
             <version>${project.version}</version>
         </dependency>
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
new file mode 100644
index 0000000000..ee58902a49
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManager.java
@@ -0,0 +1,20 @@
+package org.openecomp.sdc.versioning;
+
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.Item;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+
+public interface ItemManager {
+
+  Collection<Item> list(Predicate<Item> predicate);
+
+  Item get(String itemId);
+
+  Item create(Item item);
+
+  void updateVersionStatus(String itemId, VersionStatus addedVersionStatus,
+                           VersionStatus removedVersionStatus);
+
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManagerFactory.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManagerFactory.java
new file mode 100644
index 0000000000..314ffceadb
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/ItemManagerFactory.java
@@ -0,0 +1,31 @@
+/*-
+ * ============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;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+public abstract class ItemManagerFactory extends AbstractComponentFactory<ItemManager> {
+
+  public static ItemManagerFactory getInstance() {
+    return AbstractFactory.getInstance(ItemManagerFactory.class);
+  }
+}
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 7fab25456c..c03769462b 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
@@ -20,11 +20,14 @@
 
 package org.openecomp.sdc.versioning;
 
+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 {
@@ -54,4 +57,24 @@ public interface VersioningManager {
   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/VersioningNotificationConstansts.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/VersioningNotificationConstansts.java
new file mode 100644
index 0000000000..42161dfef7
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/VersioningNotificationConstansts.java
@@ -0,0 +1,13 @@
+package org.openecomp.sdc.versioning;
+
+/**
+ * @author avrahamg
+ * @since July 10, 2017
+ */
+public class VersioningNotificationConstansts {
+    public static final String ITEM_NAME = "itemName";
+    public static final String ITEM_ID = "itemId";
+    public static final String SUBMIT_DESCRIPTION = "description";
+    public static final String VERSION_NAME = "versionName";
+    public static final String VERSION_ID = "versionId";
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/ItemDao.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/ItemDao.java
new file mode 100644
index 0000000000..f1edc1e0c0
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/ItemDao.java
@@ -0,0 +1,15 @@
+package org.openecomp.sdc.versioning.dao;
+
+import org.openecomp.sdc.versioning.types.Item;
+
+import java.util.Collection;
+
+public interface ItemDao {
+  Collection<Item> list();
+
+  Item get(Item item);
+
+  Item create(Item item);
+
+  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/dao/ItemDaoFactory.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/ItemDaoFactory.java
new file mode 100644
index 0000000000..36edaa9aa9
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/ItemDaoFactory.java
@@ -0,0 +1,30 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+public abstract class ItemDaoFactory extends AbstractComponentFactory<ItemDao> {
+  public static ItemDaoFactory getInstance() {
+    return AbstractFactory.getInstance(ItemDaoFactory.class);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/VersionDao.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/VersionDao.java
new file mode 100644
index 0000000000..f557e4d4ec
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/VersionDao.java
@@ -0,0 +1,29 @@
+package org.openecomp.sdc.versioning.dao;
+
+import org.openecomp.sdc.versioning.dao.types.Revision;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface VersionDao {
+  List<Version> list(String itemId);
+
+  void create(String itemId, Version version);
+
+  void update(String itemId, Version version);
+
+  Optional<Version> get(String itemId, Version version);
+
+  void delete(String itemId, Version version);
+
+  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/dao/VersionDaoFactory.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/VersionDaoFactory.java
new file mode 100644
index 0000000000..845b248d7e
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/VersionDaoFactory.java
@@ -0,0 +1,30 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.versioning.dao;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+public abstract class VersionDaoFactory extends AbstractComponentFactory<VersionDao> {
+  public static VersionDaoFactory getInstance() {
+    return AbstractFactory.getInstance(VersionDaoFactory.class);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/Revision.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/Revision.java
new file mode 100644
index 0000000000..492e75fdbb
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/Revision.java
@@ -0,0 +1,42 @@
+package org.openecomp.sdc.versioning.dao.types;
+
+import java.util.Date;
+
+public class Revision {
+  private String id;
+  private String message;
+  private Date time;
+  private String user;
+
+  public String getId() {
+    return id;
+  }
+
+  public void setId(String id) {
+    this.id = id;
+  }
+
+  public void setMessage(String message) {
+    this.message = message;
+  }
+
+  public void setTime(Date time) {
+    this.time = time;
+  }
+
+  public String getMessage() {
+    return message;
+  }
+
+  public Date getTime() {
+    return time;
+  }
+
+  public String getUser() {
+    return user;
+  }
+
+  public void setUser(String user) {
+    this.user = user;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/SynchronizationState.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/SynchronizationState.java
new file mode 100644
index 0000000000..f0142d3e70
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/SynchronizationState.java
@@ -0,0 +1,17 @@
+package org.openecomp.sdc.versioning.dao.types;
+
+public enum SynchronizationState {
+  UpToDate("Up to date"),
+  OutOfSync("Out of sync"),
+  Merging("Merging");
+
+  private String displayName;
+
+  SynchronizationState(String displayName) {
+    this.displayName = displayName;
+  }
+
+  public String toString() {
+    return this.displayName;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/Version.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/Version.java
index 82b79c6bda..b1f0b71d90 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/Version.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/Version.java
@@ -22,23 +22,44 @@ package org.openecomp.sdc.versioning.dao.types;
 
 import com.datastax.driver.mapping.annotations.Transient;
 import com.datastax.driver.mapping.annotations.UDT;
-import org.openecomp.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
+
+import java.util.Date;
+import java.util.Map;
 
 @UDT(name = "version", keyspace = "dox")
 public class Version {
-  private static final Logger logger = LoggerFactory.getLogger(Version.class);
   public static final String VERSION_STRING_VIOLATION_MSG =
       "Version string must be in the format of: {integer}.{integer}";
 
-  private int major;
-  private int minor;
   @Transient
-  private VersionStatus status = VersionStatus.Available;
+  private String id;
+  private int major; // TODO: 6/7/2017 remove!
+  private int minor; // TODO: 6/7/2017 remove!
+  @Transient
+  private String name;
+  @Transient
+  private String description;
+  @Transient
+  private String baseId;
+  @Transient
+  private Date creationTime;
+  @Transient
+  private Date modificationTime;
+  @Transient
+  private VersionStatus status = VersionStatus.Draft;
+  @Transient
+  private VersionState state;
+  @Transient
+  private Map<String, Object> additionalInfo;
 
   public Version() {
   }
 
+  public Version(String id) {
+    this.id = id;
+  }
+
+  @Deprecated
   public Version(int major, int minor) {
     this.major = major;
     this.minor = minor;
@@ -62,7 +83,6 @@ public class Version {
     try {
       version = new Version(Integer.parseInt(versionLevels[0]), Integer.parseInt(versionLevels[1]));
     } catch (Exception ex) {
-      logger.debug(ex.getMessage(), ex);
       throw new IllegalArgumentException(VERSION_STRING_VIOLATION_MSG);
     }
 
@@ -85,6 +105,54 @@ public class Version {
     this.minor = minor;
   }
 
+  public String getId() {
+    return id;
+  }
+
+  public void setId(String id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+
+  public String getBaseId() {
+    return baseId;
+  }
+
+  public void setBaseId(String baseId) {
+    this.baseId = baseId;
+  }
+
+  public Date getCreationTime() {
+    return creationTime;
+  }
+
+  public void setCreationTime(Date creationTime) {
+    this.creationTime = creationTime;
+  }
+
+  public Date getModificationTime() {
+    return modificationTime;
+  }
+
+  public void setModificationTime(Date modificationTime) {
+    this.modificationTime = modificationTime;
+  }
+
   public VersionStatus getStatus() {
     return status;
   }
@@ -93,6 +161,14 @@ public class Version {
     this.status = status;
   }
 
+  public VersionState getState() {
+    return state;
+  }
+
+  public void setState(VersionState state) {
+    this.state = state;
+  }
+
   public Version calculateNextCandidate() {
     return new Version(major, minor + 1);
   }
@@ -105,6 +181,14 @@ public class Version {
     return major != 0 && minor == 0;
   }
 
+  public Map<String, Object> getAdditionalInfo() {
+    return additionalInfo;
+  }
+
+  public void setAdditionalInfo(Map<String, Object> additionalInfo) {
+    this.additionalInfo = additionalInfo;
+  }
+
   @Override
   public int hashCode() {
     int result = major;
@@ -138,6 +222,21 @@ public class Version {
 
   @Override
   public String toString() {
-    return major + "." + minor;
+    return name != null ? name : major + "." + minor;
+  }
+
+  @Override
+  public Version clone() {
+    Version version = new Version();
+    version.setStatus(this.getStatus());
+    version.setCreationTime(this.getCreationTime());
+    version.setName(this.getName());
+    version.setBaseId(this.getBaseId());
+    version.setMajor(this.major);
+    version.setMinor(this.minor);
+    version.setModificationTime(this.getModificationTime());
+    version.setDescription(this.description);
+    version.setId(this.getId());
+    return version;
   }
-}
+}
+\ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/VersionState.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/VersionState.java
new file mode 100644
index 0000000000..8d489802b7
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/VersionState.java
@@ -0,0 +1,23 @@
+package org.openecomp.sdc.versioning.dao.types;
+
+public class VersionState {
+  private SynchronizationState synchronizationState;
+  private boolean dirty;
+
+  public SynchronizationState getSynchronizationState() {
+    return synchronizationState;
+  }
+
+  public void setSynchronizationState(
+      SynchronizationState synchronizationState) {
+    this.synchronizationState = synchronizationState;
+  }
+
+  public boolean isDirty() {
+    return dirty;
+  }
+
+  public void setDirty(boolean dirty) {
+    this.dirty = dirty;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/VersionStatus.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/VersionStatus.java
index cf980d6b51..e330b9506a 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/VersionStatus.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/dao/types/VersionStatus.java
@@ -21,7 +21,7 @@
 package org.openecomp.sdc.versioning.dao.types;
 
 public enum VersionStatus {
-  Available,
-  Locked,
-  Final
+  Draft,
+  Locked, /* todo remove!!*/
+  Certified
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/EditOnUnlockedEntityErrorBuilder.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/EditOnUnlockedEntityErrorBuilder.java
index 4de5618e75..367a93b630 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/EditOnUnlockedEntityErrorBuilder.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/EditOnUnlockedEntityErrorBuilder.java
@@ -20,11 +20,11 @@
 
 package org.openecomp.sdc.versioning.errors;
 
-import static org.openecomp.sdc.versioning.errors.VersioningErrorCodes.EDIT_ON_UNLOCKED_ENTITY;
-
 import org.openecomp.sdc.common.errors.BaseErrorBuilder;
 import org.openecomp.sdc.common.errors.ErrorCategory;
 
+import static org.openecomp.sdc.versioning.errors.VersioningErrorCodes.EDIT_ON_UNLOCKED_ENTITY;
+
 /**
  * The type Edit on unlocked entity error builder.
  */
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/RevisionIdNotFoundErrorBuilder.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/RevisionIdNotFoundErrorBuilder.java
new file mode 100644
index 0000000000..0075403acf
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/RevisionIdNotFoundErrorBuilder.java
@@ -0,0 +1,44 @@
+/*-
+ * ============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.errors;
+
+import org.openecomp.sdc.common.errors.BaseErrorBuilder;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+
+/**
+ * The mandatory field revision id not found error builder.
+ */
+public class RevisionIdNotFoundErrorBuilder extends BaseErrorBuilder {
+
+  private static final String REVISION_ID_NOT_FOUND_MSG =
+      "Mandatory field revision id missing";
+
+  /**
+   * Instantiates a new Versionable sub entity not found error builder.
+   */
+  public RevisionIdNotFoundErrorBuilder() {
+    getErrorCodeBuilder().withId(VersioningErrorCodes.MANDATORY_FIELD_REVISION_ID_MISSING);
+    getErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION);
+    getErrorCodeBuilder().withMessage(REVISION_ID_NOT_FOUND_MSG);
+  }
+
+
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersionableSubEntityNotFoundErrorBuilder.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersionableSubEntityNotFoundErrorBuilder.java
index 77be83f427..f717e5dbdc 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersionableSubEntityNotFoundErrorBuilder.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersionableSubEntityNotFoundErrorBuilder.java
@@ -53,7 +53,7 @@ public class VersionableSubEntityNotFoundErrorBuilder extends BaseErrorBuilder {
     getErrorCodeBuilder().withCategory(ErrorCategory.APPLICATION);
     getErrorCodeBuilder().withMessage(String
         .format(SUB_ENTITY_NOT_FOUND_MSG, entityType, entityId, containingEntityType,
-            containingEntityId, version.toString()));
+            containingEntityId, version.getId()));
   }
 
   /**
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersioningErrorCodes.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersioningErrorCodes.java
index c1c6b96bfd..3dd87d5a3f 100644
--- a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersioningErrorCodes.java
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/errors/VersioningErrorCodes.java
@@ -40,4 +40,10 @@ public class VersioningErrorCodes {
   public static final String UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER =
       "UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER";
   public static final String UNDO_CHECKOUT_ON_UNLOCKED_ENTITY = "UNDO_CHECKOUT_ON_UNLOCKED_ENTITY";
+  public static final String MANDATORY_FIELD_REVISION_ID_MISSING =
+      "MANDATORY_FIELD_REVISION_ID_MISSING";
+
+
+
+
 }
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/Item.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/Item.java
new file mode 100644
index 0000000000..329ac52133
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/Item.java
@@ -0,0 +1,103 @@
+package org.openecomp.sdc.versioning.types;
+
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Item {
+  private String id;
+  private String type;
+  private String name;
+  private String description;
+  private Map<String, Object> properties = new HashMap<>();
+  private Map<VersionStatus, Integer> versionStatusCounters = new HashMap<>();
+  private Date creationTime;
+  private Date modificationTime;
+
+  public String getId() {
+    return id;
+  }
+
+  public void setId(String id) {
+    this.id = id;
+  }
+
+  public String getType() {
+    return type;
+  }
+
+  public void setType(String type) {
+    this.type = type;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public void setDescription(String description) {
+    this.description = description;
+  }
+
+  public Map<String, Object> getProperties() {
+    return properties;
+  }
+
+  public void addProperty(String key, Object value) {
+    properties.put(key, value);
+  }
+
+  public void setProperties(Map<String, Object> properties) {
+    this.properties = properties;
+  }
+
+  public Map<VersionStatus, Integer> getVersionStatusCounters() {
+    return versionStatusCounters;
+  }
+
+  public void setVersionStatusCounters(Map<VersionStatus, Integer> versionStatusCounters) {
+    this.versionStatusCounters = versionStatusCounters;
+  }
+
+  public void addVersionStatus(VersionStatus versionStatus) {
+    Integer counter = versionStatusCounters.get(versionStatus);
+    versionStatusCounters
+        .put(versionStatus, counter == null ? 1 : counter + 1);
+  }
+
+  public void removeVersionStatus(VersionStatus versionStatus) {
+    Integer counter = versionStatusCounters.get(versionStatus);
+    if (counter != null) {
+      if (counter == 1) {
+        versionStatusCounters.remove(versionStatus);
+      } else {
+        versionStatusCounters.put(versionStatus, counter - 1);
+      }
+    }
+  }
+
+  public Date getCreationTime() {
+    return creationTime;
+  }
+
+  public void setCreationTime(Date creationTime) {
+    this.creationTime = creationTime;
+  }
+
+  public Date getModificationTime() {
+    return modificationTime;
+  }
+
+  public void setModificationTime(Date modificationTime) {
+    this.modificationTime = modificationTime;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/NotificationEventTypes.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/NotificationEventTypes.java
new file mode 100644
index 0000000000..b62f7b53e1
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/NotificationEventTypes.java
@@ -0,0 +1,20 @@
+package org.openecomp.sdc.versioning.types;
+
+/**
+ * @author avrahamg
+ * @since July 10, 2017
+ */
+public enum NotificationEventTypes {
+    SUBMIT("submit"),
+    COMMIT("commit");
+
+    private String eventName;
+
+    NotificationEventTypes(String eventName) {
+        this.eventName = eventName;
+    }
+
+    public String getEventName() {
+        return eventName;
+    }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/VersionCreationMethod.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/VersionCreationMethod.java
new file mode 100644
index 0000000000..6404b6b280
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-api/src/main/java/org/openecomp/sdc/versioning/types/VersionCreationMethod.java
@@ -0,0 +1,8 @@
+package org.openecomp.sdc.versioning.types;
+
+public enum VersionCreationMethod {
+  /*parent_level,
+  same_level,
+  sub_level*/
+  major,minor
+}
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 e38ad1a8b4..90d11f1700 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,10 @@
 {
+  "org.openecomp.sdc.versioning.ItemManagerFactory": "org.openecomp.sdc.versioning.impl.ItemManagerFactoryImpl",
   "org.openecomp.sdc.versioning.VersioningManagerFactory": "org.openecomp.sdc.versioning.impl.VersioningManagerFactoryImpl",
   "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"
+  "org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory": "org.openecomp.sdc.versioning.dao.impl.VersionInfoDeletedDaoFactoryImpl",
+  "org.openecomp.sdc.versioning.dao.ItemDaoFactory": "org.openecomp.sdc.versioning.dao.impl.ItemDaoFactoryImpl",
+  "org.openecomp.sdc.versioning.dao.VersionDaoFactory": "org.openecomp.sdc.versioning.dao.impl.VersionDaoFactoryImpl",
+  "org.openecomp.sdc.versioning.dao.HealthCheckDaoFactory": "org.openecomp.sdc.model.impl.HealthCheckDaoFactoryImpl"
 }
 \ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/VersionCalculator.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/VersionCalculator.java
new file mode 100644
index 0000000000..dc9ac7b325
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/VersionCalculator.java
@@ -0,0 +1,12 @@
+package org.openecomp.sdc.versioning;
+
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.types.VersionCreationMethod;
+
+import java.util.Set;
+
+public interface VersionCalculator {
+  String calculate(String baseVersion, VersionCreationMethod creationMethod);
+
+  void injectAdditionalInfo(Version version, Set<String> existingVersions);
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/VersionCalculatorFactory.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/VersionCalculatorFactory.java
new file mode 100644
index 0000000000..85f02cd267
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/VersionCalculatorFactory.java
@@ -0,0 +1,31 @@
+/*-
+ * ============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;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+public abstract class VersionCalculatorFactory extends AbstractComponentFactory<VersionCalculator> {
+
+  public static VersionCalculatorFactory getInstance() {
+    return AbstractFactory.getInstance(VersionCalculatorFactory.class);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/ItemDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/ItemDaoFactoryImpl.java
new file mode 100644
index 0000000000..0f9c9065d4
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/ItemDaoFactoryImpl.java
@@ -0,0 +1,36 @@
+/*-
+ * ============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.core.zusammen.api.ZusammenAdaptorFactory;
+import org.openecomp.sdc.versioning.dao.ItemDao;
+import org.openecomp.sdc.versioning.dao.ItemDaoFactory;
+import org.openecomp.sdc.versioning.dao.impl.zusammen.ItemZusammenDaoImpl;
+
+public class ItemDaoFactoryImpl extends ItemDaoFactory {
+  private static ItemDao INSTANCE =
+      new ItemZusammenDaoImpl(ZusammenAdaptorFactory.getInstance().createInterface());
+
+  @Override
+  public ItemDao 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/VersionDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionDaoFactoryImpl.java
new file mode 100644
index 0000000000..f8b0d71eb7
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/VersionDaoFactoryImpl.java
@@ -0,0 +1,36 @@
+/*-
+ * ============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.core.zusammen.api.ZusammenAdaptorFactory;
+import org.openecomp.sdc.versioning.dao.VersionDao;
+import org.openecomp.sdc.versioning.dao.VersionDaoFactory;
+import org.openecomp.sdc.versioning.dao.impl.zusammen.VersionZusammenDaoImpl;
+
+public class VersionDaoFactoryImpl extends VersionDaoFactory {
+  private static VersionDao INSTANCE =
+      new VersionZusammenDaoImpl(ZusammenAdaptorFactory.getInstance().createInterface());
+
+  @Override
+  public VersionDao 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/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
index 5673da7070..0845beaa2f 100644
--- 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
@@ -24,12 +24,12 @@ 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.sdc.logging.api.Logger;
-import org.openecomp.sdc.logging.api.LoggerFactory;
 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.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.versioning.dao.VersionableEntityDao;
 import org.openecomp.sdc.versioning.dao.types.Version;
 import org.openecomp.sdc.versioning.types.UniqueValueMetadata;
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/ItemZusammenDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/ItemZusammenDaoImpl.java
new file mode 100644
index 0000000000..8fdcf71d59
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/ItemZusammenDaoImpl.java
@@ -0,0 +1,104 @@
+package org.openecomp.sdc.versioning.dao.impl.zusammen;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.item.Info;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.core.zusammen.api.ZusammenUtil;
+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.Map;
+import java.util.stream.Collectors;
+
+public class ItemZusammenDaoImpl implements ItemDao {
+
+  private ZusammenAdaptor zusammenAdaptor;
+
+  public ItemZusammenDaoImpl(ZusammenAdaptor zusammenAdaptor) {
+    this.zusammenAdaptor = zusammenAdaptor;
+  }
+
+  @Override
+  public Collection<Item> list() {
+    return zusammenAdaptor.listItems(ZusammenUtil.createSessionContext())
+        .stream().map(this::mapFromZusammenItem)
+        .collect(Collectors.toList());
+  }
+
+  @Override
+  public Item get(Item item) {
+    return mapFromZusammenItem(
+        zusammenAdaptor.getItem(ZusammenUtil.createSessionContext(), new Id(item.getId())));
+  }
+
+  @Override
+  public Item create(Item item) {
+    Id itemId = zusammenAdaptor
+        .createItem(ZusammenUtil.createSessionContext(), mapToZusammenItemInfo(item));
+    item.setId(itemId.getValue());
+    return item;
+  }
+
+  @Override
+  public void update(Item item) {
+    zusammenAdaptor
+        .updateItem(ZusammenUtil.createSessionContext(), new Id(item.getId()),
+            mapToZusammenItemInfo(item));
+  }
+
+  private Item mapFromZusammenItem(com.amdocs.zusammen.datatypes.item.Item zusammenItem) {
+    if (zusammenItem == null) {
+      return null;
+    }
+    Item item = new Item();
+    item.setId(zusammenItem.getId().getValue());
+    item.setName(zusammenItem.getInfo().getName());
+    item.setDescription(zusammenItem.getInfo().getDescription());
+
+    zusammenItem.getInfo().getProperties().entrySet()
+        .forEach(property -> addPropertyToItem(property.getKey(), property.getValue(), item));
+
+    item.setCreationTime(zusammenItem.getCreationTime());
+    item.setModificationTime(zusammenItem.getModificationTime());
+    return item;
+  }
+
+  private void addPropertyToItem(String propertyKey, Object propertyValue, Item item) {
+    switch (propertyKey) {
+      case InfoPropertyName.ITEM_TYPE:
+        item.setType((String) propertyValue);
+        break;
+      case InfoPropertyName.ITEM_VERSIONS_STATUSES:
+        for (Map.Entry<String, Number> statusCounter :
+            ((Map<String, Number>) propertyValue).entrySet()) {
+          item.getVersionStatusCounters().put(VersionStatus.valueOf(statusCounter.getKey()),
+              statusCounter.getValue().intValue());
+        }
+        break;
+      default:
+        item.addProperty(propertyKey, propertyValue);
+    }
+  }
+
+  private Info mapToZusammenItemInfo(Item item) {
+    Info info = new Info();
+    info.setName(item.getName());
+    info.setDescription(item.getDescription());
+    info.addProperty(InfoPropertyName.ITEM_TYPE, item.getType());
+    info.addProperty(InfoPropertyName.ITEM_VERSIONS_STATUSES, item.getVersionStatusCounters());
+    item.getProperties().entrySet()
+        .forEach(property -> info.addProperty(property.getKey(), property.getValue()));
+    return info;
+  }
+
+  private static final class InfoPropertyName {
+    private static final String ITEM_TYPE = "item_type";
+    private static final String ITEM_VERSIONS_STATUSES = "item_versions_statuses";
+
+    private InfoPropertyName() {
+      throw new IllegalStateException("Constants class");
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/VersionZusammenDaoImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/VersionZusammenDaoImpl.java
new file mode 100644
index 0000000000..195973bf5c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/VersionZusammenDaoImpl.java
@@ -0,0 +1,165 @@
+package org.openecomp.sdc.versioning.dao.impl.zusammen;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Info;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import com.amdocs.zusammen.datatypes.item.ItemVersionData;
+import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
+import com.amdocs.zusammen.datatypes.item.SynchronizationStatus;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+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.versioning.dao.VersionDao;
+import org.openecomp.sdc.versioning.dao.impl.zusammen.convertor.ItemVersionToVersionConvertor;
+import org.openecomp.sdc.versioning.dao.types.Revision;
+import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionState;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
+
+public class VersionZusammenDaoImpl implements VersionDao {
+
+  public static final class ZusammenProperty {
+    public static final String LABEL = "label";
+    public static final String STATUS = "status";
+
+    private ZusammenProperty() {
+      throw new IllegalStateException("Constants class");
+    }
+  }
+
+  private ZusammenAdaptor zusammenAdaptor;
+
+  public VersionZusammenDaoImpl(ZusammenAdaptor zusammenAdaptor) {
+    this.zusammenAdaptor = zusammenAdaptor;
+  }
+
+  @Override
+  public List<Version> list(String itemId) {
+    ItemVersionToVersionConvertor convertor = new ItemVersionToVersionConvertor();
+    return zusammenAdaptor.listPublicVersions(createSessionContext(), new Id(itemId)).stream()
+        .map(convertor::convert)
+        .collect(Collectors.toList());
+  }
+
+  @Override
+  public void create(String itemId, Version version) {
+    Id versionId =
+        zusammenAdaptor.createVersion(createSessionContext(), new Id(itemId),
+            version.getBaseId() == null ? null : new Id(version.getBaseId()),
+            mapToZusammenVersion(version));
+
+    version.setId(versionId.getValue());
+  }
+
+  @Override
+  public void update(String itemId, Version version) {
+    zusammenAdaptor.updateVersion(createSessionContext(), new Id(itemId), new Id(version.getId()),
+        mapToZusammenVersion(version));
+  }
+
+  @Override
+  public Optional<Version> get(String itemId, Version version) {
+    SessionContext context = createSessionContext();
+    Id itemIdObj = new Id(itemId);
+    Id versionId = new Id(version.getId());
+    ItemVersion itemVersion = zusammenAdaptor.getVersion(context, itemIdObj, versionId);
+
+    if (itemVersion == null) {
+      return Optional.empty();
+    }
+
+    VersionState versionState =
+        convertState(zusammenAdaptor.getVersionStatus(context, itemIdObj, versionId));
+    updateVersionStatus(context, itemIdObj, versionId, versionState, itemVersion);
+
+    Version result = new ItemVersionToVersionConvertor().convert(itemVersion);
+    result.setState(versionState);
+    return Optional.of(result);
+  }
+
+  @Override
+  public void delete(String itemId, Version version) {
+    throw new UnsupportedOperationException("Delete version operation is not yet supported.");
+  }
+
+  @Override
+  public void publish(String itemId, Version version, String message) {
+    zusammenAdaptor
+        .publishVersion(createSessionContext(), new Id(itemId), new Id(version.getId()), message);
+  }
+
+  @Override
+  public void sync(String itemId, Version version) {
+    zusammenAdaptor
+        .syncVersion(createSessionContext(), new Id(itemId), new Id(version.getId()));
+  }
+
+  @Override
+  public void forceSync(String itemId, Version version) {
+    zusammenAdaptor
+        .forceSyncVersion(createSessionContext(), new Id(itemId), new Id(version.getId()));
+  }
+
+  @Override
+  public void revert(String itemId, Version version, String revisionId) {
+    zusammenAdaptor.revert(createSessionContext(), itemId, version.getId(), revisionId);
+  }
+
+  @Override
+  public List<Revision> listRevisions(String itemId, Version version) {
+    return zusammenAdaptor.listRevisions(createSessionContext(), itemId, version.getId());
+  }
+
+  private void updateVersionStatus(SessionContext context, Id itemId, Id versionId,
+                                   VersionState versionState, ItemVersion itemVersion) {
+    if (versionState.getSynchronizationState() != SynchronizationState.UpToDate ||
+        versionState.isDirty()) {
+      String versionStatus = zusammenAdaptor.getPublicVersion(context, itemId, versionId)
+          .getData().getInfo().getProperty(ZusammenProperty.STATUS);
+      itemVersion.getData().getInfo().addProperty(ZusammenProperty.STATUS, versionStatus);
+    }
+  }
+
+  private ItemVersionData mapToZusammenVersion(Version version) {
+    Info info = new Info();
+    info.addProperty(ZusammenProperty.LABEL, version.toString());
+    info.addProperty(ZusammenProperty.STATUS, version.getStatus().name());
+    info.setName(version.getName());
+    info.setDescription(version.getDescription());
+
+    ItemVersionData itemVersionData = new ItemVersionData();
+    itemVersionData.setInfo(info);
+    return itemVersionData;
+  }
+
+  private VersionState convertState(ItemVersionStatus versionStatus) {
+    VersionState state = new VersionState();
+    state.setSynchronizationState(getSyncState(versionStatus.getSynchronizationStatus()));
+    state.setDirty(versionStatus.isDirty());
+    return state;
+  }
+
+  private SynchronizationState getSyncState(SynchronizationStatus synchronizationStatus) {
+    switch (synchronizationStatus) {
+      case UP_TO_DATE:
+        return SynchronizationState.UpToDate;
+      case OUT_OF_SYNC:
+        return SynchronizationState.OutOfSync;
+      case MERGING:
+        return SynchronizationState.Merging;
+      default:
+        throw new CoreException(new ErrorCode.ErrorCodeBuilder()
+            .withCategory(ErrorCategory.APPLICATION)
+            .withId("UNKNOWN_VERSION_STATE")
+            .withMessage("Version state is unknown").build());
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/convertor/ItemVersionToVersionConvertor.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/convertor/ItemVersionToVersionConvertor.java
new file mode 100644
index 0000000000..f47b5aa612
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/dao/impl/zusammen/convertor/ItemVersionToVersionConvertor.java
@@ -0,0 +1,49 @@
+package org.openecomp.sdc.versioning.dao.impl.zusammen.convertor;
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
+import com.amdocs.zusammen.datatypes.item.Item;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import org.openecomp.convertor.ElementConvertor;
+import org.openecomp.sdc.versioning.dao.impl.zusammen.VersionZusammenDaoImpl;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+
+public class ItemVersionToVersionConvertor extends ElementConvertor {
+  @Override
+  public Object convert(Element element) {
+    return null;
+  }
+
+  @Override
+  public Object convert(Item item) {
+    return null;
+  }
+
+  @Override
+  public Object convert(ElementInfo elementInfo) {
+    return null;
+  }
+
+  @Override
+  public Version convert(ItemVersion itemVersion) {
+    if (itemVersion == null) {
+      return null;
+    }
+    Version version = Version.valueOf(
+        itemVersion.getData().getInfo().getProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL));
+    version.setStatus(VersionStatus.valueOf(itemVersion.getData().getInfo()
+        .getProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS)));
+    version.setName(itemVersion.getData().getInfo().getName());
+    version.setDescription(itemVersion.getData().getInfo().getDescription());
+
+    version.setId(itemVersion.getId().getValue());
+    if (itemVersion.getBaseId() != null) {
+      version.setBaseId(itemVersion.getBaseId().getValue());
+    }
+    version.setCreationTime(itemVersion.getCreationTime());
+    version.setModificationTime(itemVersion.getModificationTime());
+    return version;
+  }
+
+}
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
new file mode 100644
index 0000000000..ba5bd07d42
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerFactoryImpl.java
@@ -0,0 +1,39 @@
+/*-
+ * ============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.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());
+
+  @Override
+  public ItemManager 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/ItemManagerImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerImpl.java
new file mode 100644
index 0000000000..79284542fb
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/ItemManagerImpl.java
@@ -0,0 +1,68 @@
+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.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 {
+  public static final String CREATE_ITEM = "Create_Item";
+
+  private ItemDao itemDao;
+  private PermissionsServices permissionsServices;
+  private SubscriptionService subscriptionService;
+
+  public ItemManagerImpl(ItemDao itemDao, PermissionsServices permissionsServices,
+                         SubscriptionService subscriptionService) {
+    this.itemDao = itemDao;
+    this.permissionsServices = permissionsServices;
+    this.subscriptionService = subscriptionService;
+  }
+
+  @Override
+  public Collection<Item> list(Predicate<Item> predicate) {
+    return itemDao.list().stream().filter(predicate).collect(Collectors.toList());
+  }
+
+  @Override
+  public Item get(String itemId) {
+    Item item = new Item();
+    item.setId(itemId);
+    return itemDao.get(item);
+  }
+
+  @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;
+  }
+
+  @Override
+  public void updateVersionStatus(String itemId, VersionStatus addedVersionStatus,
+                                  VersionStatus removedVersionStatus) {
+    Item item = get(itemId);
+    if (item == null) {
+      return;
+    }
+
+    item.addVersionStatus(addedVersionStatus);
+    if (removedVersionStatus != null) {
+      item.removeVersionStatus(removedVersionStatus);
+    }
+    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/MajorVersionCalculatorFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/MajorVersionCalculatorFactoryImpl.java
new file mode 100644
index 0000000000..2300f62180
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/MajorVersionCalculatorFactoryImpl.java
@@ -0,0 +1,14 @@
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.sdc.versioning.VersionCalculator;
+import org.openecomp.sdc.versioning.VersionCalculatorFactory;
+
+public class MajorVersionCalculatorFactoryImpl extends VersionCalculatorFactory {
+  private static final VersionCalculator INSTANCE =
+      new MajorVersionCalculatorImpl();
+
+  @Override
+  public VersionCalculator 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/MajorVersionCalculatorImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/MajorVersionCalculatorImpl.java
new file mode 100644
index 0000000000..91c59e0efd
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/MajorVersionCalculatorImpl.java
@@ -0,0 +1,53 @@
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.core.utilities.CommonMethods;
+import org.openecomp.sdc.versioning.VersionCalculator;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.VersionCreationMethod;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class MajorVersionCalculatorImpl implements VersionCalculator {
+  private static final String INITIAL_VERSION = "1.0";
+  private static final String VERSION_STRING_VIOLATION_MSG =
+      "Version string must be in the format of: {integer}.{integer}";
+
+  @Override
+  public String calculate(String baseVersion, VersionCreationMethod creationMethod) {
+
+    if (baseVersion == null) {
+      return INITIAL_VERSION;
+    }
+
+    String[] versionLevels = baseVersion.split("\\.");
+    if (versionLevels.length != 2) {
+      throw new IllegalArgumentException(VERSION_STRING_VIOLATION_MSG);
+    }
+
+    int index = Integer.parseInt(versionLevels[0]);
+    index++;
+    versionLevels[0] = Integer.toString(index);
+    versionLevels[1] = "0";
+
+    return CommonMethods.arrayToSeparatedString(versionLevels, '.');
+  }
+
+  @Override
+  public void injectAdditionalInfo(Version version, Set<String> existingVersions) {
+    String optionalVersion;
+    Set<VersionCreationMethod> optionalCreationMethods = new HashSet<>();
+    if(version.getStatus().equals(VersionStatus.Certified)) {
+      try {
+        optionalVersion = calculate(version.getName(), VersionCreationMethod.major);
+        if (!existingVersions.contains(optionalVersion)) {
+          optionalCreationMethods.add(VersionCreationMethod.major);
+        }
+      } catch (IllegalArgumentException iae) {
+        //not a valid creation method.
+      }
+    }
+    version.getAdditionalInfo().put("OptionalCreationMethods", optionalCreationMethods);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersionCalculatorFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersionCalculatorFactoryImpl.java
new file mode 100644
index 0000000000..155aa9c5e6
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersionCalculatorFactoryImpl.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.impl;
+
+import org.openecomp.sdc.versioning.VersionCalculator;
+import org.openecomp.sdc.versioning.VersionCalculatorFactory;
+
+public class VersionCalculatorFactoryImpl extends VersionCalculatorFactory {
+  private static final VersionCalculator INSTANCE =
+      new VersionCalculatorImpl();
+
+  @Override
+  public VersionCalculator 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/VersionCalculatorImpl.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersionCalculatorImpl.java
new file mode 100644
index 0000000000..b7008de867
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/java/org/openecomp/sdc/versioning/impl/VersionCalculatorImpl.java
@@ -0,0 +1,155 @@
+package org.openecomp.sdc.versioning.impl;
+
+import org.openecomp.core.utilities.CommonMethods;
+import org.openecomp.sdc.versioning.VersionCalculator;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.VersionCreationMethod;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class VersionCalculatorImpl implements VersionCalculator {
+
+  private static final String INITIAL_VERSION = "1.0";
+  private static final String VERSION_STRING_VIOLATION_MSG =
+      "Version string must be in the format of: {integer}.{integer}";
+  private static final String PARENT_LEVEL_VERSION_CANNOT_BE_CREATED_FROM_TOP_LEVEL =
+      "Creation of parent level version on top level version is invalid.";
+  private static final String SUB_LEVEL_VERSION_CANNOT_BE_CREATED_FROM_LOWEST_LEVEL =
+      "Creation of parent level version on top level version is invalid.";
+
+  private static final String VERSION_CALCULATION_ERROR_MSG =
+      "Version calculation error.";
+
+  private static final String INVALID_CREATION_METHOD_MSG = "Invalid creation method-";
+
+
+  @Override
+  public String calculate(String baseVersion, VersionCreationMethod creationMethod) {
+
+    if (baseVersion == null) {
+      return INITIAL_VERSION;
+    }
+
+    String[] versionLevels = baseVersion.split("\\.");
+    if (versionLevels.length != 2) {
+      throw new IllegalArgumentException(VERSION_STRING_VIOLATION_MSG);
+    }
+
+    int index;
+    switch (creationMethod) {
+      case major:
+        index = Integer.parseInt(versionLevels[0]);
+        index++;
+        versionLevels[0] = Integer.toString(index);
+        versionLevels[1] = "0";
+        break;
+      case minor:
+        index = Integer.parseInt(versionLevels[1]);
+        index++;
+        versionLevels[1] = Integer.toString(index);
+        break;
+    }
+    return CommonMethods.arrayToSeparatedString(versionLevels, '.');
+  }
+
+
+  // version calculator when there are no version restrictions
+ /* @Override
+  public String calculate(String baseVersion, VersionCreationMethod creationMethod) {
+
+    return calculate(baseVersion,creationMethod,2);
+  }
+
+  private String calculate(String baseVersion, VersionCreationMethod creationMethod,int
+      maxVersionLevels) {
+    if (baseVersion == null) {
+      return INITIAL_VERSION;
+    }
+
+    String[] versionLevels = baseVersion.split("\\.");
+    if (versionLevels.length > maxVersionLevels) {
+      throw new IllegalArgumentException(VERSION_STRING_VIOLATION_MSG);
+    }
+
+    int index;
+    int versionLevel = calcVersionLevel(versionLevels);
+    if (versionLevel == -1) {
+      throw new IllegalArgumentException(
+          VERSION_STRING_VIOLATION_MSG + " given version:" + baseVersion);
+    }
+    int requiredVersionLevelIncrease;
+    switch (creationMethod) {
+      case parent_level:
+        if (versionLevel == 0) {
+          throw new IllegalArgumentException(
+              PARENT_LEVEL_VERSION_CANNOT_BE_CREATED_FROM_TOP_LEVEL + " version:" + baseVersion);
+
+        }
+        requiredVersionLevelIncrease = versionLevel - 1;
+        versionLevels[versionLevel] = "0";
+        index = Integer.getInteger(versionLevels[requiredVersionLevelIncrease]);
+        index++;
+        versionLevels[requiredVersionLevelIncrease] = Integer.toString(index);
+        break;
+      case same_level:
+        requiredVersionLevelIncrease = versionLevel;
+        index = Integer.valueOf(versionLevels[requiredVersionLevelIncrease]);
+        index++;
+        versionLevels[requiredVersionLevelIncrease] = Integer.toString(index);
+        break;
+      case sub_level:
+        if (versionLevel == versionLevels.length - 1) {
+          throw new IllegalArgumentException(
+              SUB_LEVEL_VERSION_CANNOT_BE_CREATED_FROM_LOWEST_LEVEL + " version:" + baseVersion);
+        }
+        requiredVersionLevelIncrease = versionLevel + 1;
+        if(requiredVersionLevelIncrease>maxVersionLevels){
+          throw new IllegalArgumentException(INVALID_CREATION_METHOD_MSG+" max " +
+              "levels:"+maxVersionLevels + "requested level:"+requiredVersionLevelIncrease);
+        }
+        String newVersion = baseVersion + ".1";
+        versionLevels = newVersion.split("\\.");
+
+        break;
+      default:
+        throw new IllegalArgumentException(VERSION_CALCULATION_ERROR_MSG + " base " +
+            "version:" + baseVersion + " creation method:" + creationMethod);
+
+    }
+
+    return CommonMethods.arrayToSeparatedString(versionLevels, '.');
+  }*/
+
+
+  @Override
+  public void injectAdditionalInfo(Version version, Set<String> existingVersions) {
+    String optionalVersion;
+    Set<VersionCreationMethod> optionalCreationMethods = new HashSet<>();
+    if(version.getStatus().equals(VersionStatus.Certified)) {
+      for (VersionCreationMethod versionCreationMethod : VersionCreationMethod.values()) {
+        try {
+          optionalVersion = calculate(version.getName(), versionCreationMethod);
+          if (!existingVersions.contains(optionalVersion)) {
+            optionalCreationMethods.add(versionCreationMethod);
+          }
+        } catch (IllegalArgumentException iae) {
+          //not a valid creation method.
+        }
+      }
+    }
+    version.getAdditionalInfo().put("OptionalCreationMethods", optionalCreationMethods);
+
+  }
+
+
+  private int calcVersionLevel(String[] versionLevels) {
+    for (int i = versionLevels.length - 1; i >= 0; i--) {
+      if (!versionLevels[i].equals("0")) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}
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 8ab5c608bf..b4dbcf3a08 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
@@ -20,16 +20,21 @@
 
 package org.openecomp.sdc.versioning.impl;
 
+import org.openecomp.sdc.versioning.ItemManagerFactory;
+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()
-  );
+      VersionInfoDeletedDaoFactory.getInstance().createInterface(),
+      VersionDaoFactory.getInstance().createInterface(),
+      VersionCalculatorFactory.getInstance().createInterface(),
+      ItemManagerFactory.getInstance().createInterface());
 
   @Override
   public VersioningManager 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 4a49d5391f..7f983477cf 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
@@ -21,25 +21,31 @@
 package org.openecomp.sdc.versioning.impl;
 
 import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
 import org.openecomp.sdc.datatypes.error.ErrorLevel;
+import org.openecomp.sdc.logging.api.Logger;
+import org.openecomp.sdc.logging.api.LoggerFactory;
 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
 import org.openecomp.sdc.logging.types.LoggerConstants;
 import org.openecomp.sdc.logging.types.LoggerErrorCode;
 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
+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.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;
@@ -52,6 +58,7 @@ 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;
@@ -66,18 +73,27 @@ 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 MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
   private static Map<String, Set<VersionableEntityMetadata>> versionableEntities = new HashMap<>();
 
-  private VersionInfoDao versionInfoDao;
-  private VersionInfoDeletedDao versionInfoDeletedDao;
+  private final VersionInfoDao versionInfoDao;
+  private final VersionInfoDeletedDao versionInfoDeletedDao;
+  private VersionDao versionDao;
+  private VersionCalculator versionCalculator;
+  private ItemManager itemManager;
 
   public VersioningManagerImpl(VersionInfoDao versionInfoDao,
-                               VersionInfoDeletedDao versionInfoDeletedDao) {
+                               VersionInfoDeletedDao versionInfoDeletedDao,
+                               VersionDao versionDao,
+                               VersionCalculator versionCalculator,
+                               ItemManager itemManager) {
     this.versionInfoDao = versionInfoDao;
     this.versionInfoDeletedDao = versionInfoDeletedDao;
+    this.versionDao = versionDao;
+    this.versionCalculator = versionCalculator;
+    this.itemManager = itemManager;
   }
 
   private static VersionInfo getVersionInfo(VersionInfoEntity versionInfoEntity, String user,
@@ -146,8 +162,12 @@ public class VersioningManagerImpl implements VersioningManager {
     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));
+    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));
@@ -166,11 +186,9 @@ public class VersioningManagerImpl implements VersioningManager {
 
   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());
+    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) {
@@ -263,8 +281,8 @@ public class VersioningManagerImpl implements VersioningManager {
             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't checkout versionable entity");
         throw new CoreException(new CheckoutOnLockedEntityErrorBuilder(entityType, entityId,
             versionInfoEntity.getCandidate().getUser()).build());
-      case Final:
-      case Available:
+      case Certified:
+      case Draft:
         checkoutVersion = doCheckout(versionInfoEntity, user);
         break;
       default:
@@ -300,8 +318,8 @@ public class VersioningManagerImpl implements VersioningManager {
         }
         activeVersion = undoCheckout(versionInfoEntity);
         break;
-      case Final:
-      case Available:
+      case Certified:
+      case Draft:
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
             LoggerTragetServiceName.UNDO_CHECKOUT_ENTITY, ErrorLevel.ERROR.name(),
             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(),
@@ -320,8 +338,9 @@ public class VersioningManagerImpl implements VersioningManager {
     deleteVersionFromEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
         versionInfoEntity.getCandidate().getVersion(), versionInfoEntity.getActiveVersion());
 
-    versionInfoEntity.setStatus(versionInfoEntity.getActiveVersion().isFinal() ? VersionStatus.Final
-        : VersionStatus.Available);
+    versionInfoEntity
+        .setStatus(versionInfoEntity.getActiveVersion().isFinal() ? VersionStatus.Certified
+            : VersionStatus.Draft);
     versionInfoEntity.setCandidate(null);
     versionInfoDao.update(versionInfoEntity);
     return versionInfoEntity.getActiveVersion();
@@ -341,8 +360,8 @@ public class VersioningManagerImpl implements VersioningManager {
 
     Version checkedInVersion = null;
     switch (versionInfoEntity.getStatus()) {
-      case Available:
-      case Final:
+      case Draft:
+      case Certified:
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
             LoggerTragetServiceName.CHECKIN_ENTITY, ErrorLevel.ERROR.name(),
             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't checkin versionable entity");
@@ -379,7 +398,7 @@ public class VersioningManagerImpl implements VersioningManager {
 
     Version submitVersion = null;
     switch (versionInfoEntity.getStatus()) {
-      case Final:
+      case Certified:
         MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
             LoggerTragetServiceName.SUBMIT_ENTITY, ErrorLevel.ERROR.name(),
             LoggerErrorCode.DATA_ERROR.getErrorCode(), "Can't submit versionable entity");
@@ -391,7 +410,7 @@ public class VersioningManagerImpl implements VersioningManager {
             LoggerErrorCode.PERMISSION_ERROR.getErrorCode(), "Can't submit versionable entity");
         throw new CoreException(new SubmitLockedEntityNotAllowedErrorBuilder(entityType, entityId,
             versionInfoEntity.getCandidate().getUser()).build());
-      case Available:
+      case Draft:
         submitVersion = doSubmit(versionInfoEntity, user, submitDescription);
         break;
       default:
@@ -444,6 +463,143 @@ public class VersioningManagerImpl implements VersioningManager {
     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);
+    itemManager.updateVersionStatus(itemId, VersionStatus.Draft, null);
+
+    publish(itemId, version, String.format("Initial 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);
+
+      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY,
+          LoggerTragetServiceName.CREATE_VERSION, ErrorLevel.ERROR.name(),
+          LoggerErrorCode.DATA_ERROR.getErrorCode(), errorDescription);
+
+      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);
+
+    itemManager.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());
+
+      MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
+          LoggerTragetServiceName.SUBMIT_ENTITY, ErrorLevel.ERROR.name(),
+          LoggerErrorCode.DATA_ERROR.getErrorCode(), errorDescription);
+
+      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,
@@ -491,7 +647,7 @@ public class VersioningManagerImpl implements VersioningManager {
     versionInfoEntity.setCandidate(null);
     versionInfoEntity.setActiveVersion(userCandidateVersion.getVersion());
     versionInfoEntity.getViewableVersions().add(versionInfoEntity.getActiveVersion());
-    versionInfoEntity.setStatus(VersionStatus.Available);
+    versionInfoEntity.setStatus(VersionStatus.Draft);
 
     closeVersionOnEntity(versionInfoEntity.getEntityType(), versionInfoEntity.getEntityId(),
         versionInfoEntity.getActiveVersion());
@@ -519,22 +675,12 @@ public class VersioningManagerImpl implements VersioningManager {
     versionInfoEntity.setViewableVersions(viewableVersions);
     versionInfoEntity.setActiveVersion(finalVersion);
     versionInfoEntity.setLatestFinalVersion(finalVersion);
-    versionInfoEntity.setStatus(VersionStatus.Final);
+    versionInfoEntity.setStatus(VersionStatus.Certified);
     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);
-    //versionHistoryDao.create(versionHistory);
-  }
-
   private void initVersionOnEntity(String entityType, String entityId, Version baseVersion,
                                    Version newVersion) {
     Set<VersionableEntityMetadata> entityMetadatas = versionableEntities.get(entityType);
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/resources/factoryConfiguration.json b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/resources/factoryConfiguration.json
new file mode 100644
index 0000000000..d2d16eff37
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/main/resources/factoryConfiguration.json
@@ -0,0 +1,3 @@
+{
+  "org.openecomp.sdc.versioning.VersionCalculatorFactory": "org.openecomp.sdc.versioning.impl.MajorVersionCalculatorFactoryImpl"
+}
+\ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/dao/impl/zusammen/VersionZusammenDaoImplTest.java b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/dao/impl/zusammen/VersionZusammenDaoImplTest.java
new file mode 100644
index 0000000000..1f1efdf6cb
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/dao/impl/zusammen/VersionZusammenDaoImplTest.java
@@ -0,0 +1,265 @@
+package org.openecomp.sdc.versioning.dao.impl.zusammen;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.UserInfo;
+import com.amdocs.zusammen.datatypes.item.Info;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import com.amdocs.zusammen.datatypes.item.ItemVersionData;
+import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
+import com.amdocs.zusammen.datatypes.item.SynchronizationStatus;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Matchers.isNull;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+public class VersionZusammenDaoImplTest {
+
+  private static final String USER = "user1";
+  @Mock
+  private ZusammenAdaptor zusammenAdaptorMock;
+  @InjectMocks
+  private VersionZusammenDaoImpl versionDao;
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+    SessionContextProviderFactory.getInstance().createInterface().create(USER);
+  }
+
+  @Test
+  public void testList() throws Exception {
+    String itemId = "itemId";
+    Id versionId1 = new Id("v1_id");
+    Id versionId2 = new Id("v2_id");
+    Id versionId3 = new Id("v3_id");
+
+    List<ItemVersion> zusammenVersions = Stream.of(
+        createZusammenVersion(versionId1, null, "version desc", "1.0", VersionStatus.Certified),
+        createZusammenVersion(versionId2, versionId1, "version desc", "2.0", VersionStatus.Certified
+        ),
+        createZusammenVersion(versionId3, versionId2, "version desc", "3.0", VersionStatus.Draft))
+        .collect(Collectors.toList());
+    doReturn(zusammenVersions).when(zusammenAdaptorMock)
+        .listPublicVersions(eq(createZusammenContext()), eq(new Id(itemId)));
+
+    List<Version> versions = versionDao.list(itemId);
+    Assert.assertEquals(versions.size(), 3);
+
+    int zusammenVersionIndex;
+    for (Version version : versions) {
+      zusammenVersionIndex = versionId1.getValue().equals(version.getId())
+          ? 0
+          : versionId2.getValue().equals(version.getId())
+              ? 1
+              : 2;
+      assetVersionEquals(version, zusammenVersions.get(zusammenVersionIndex));
+    }
+  }
+
+  @Test
+  public void testCreate() throws Exception {
+    testCreate(null);
+  }
+
+  @Test
+  public void testCreateBasedOn() throws Exception {
+    testCreate("baseId");
+  }
+
+  private void testCreate(String baseId) {
+    String itemId = "itemId";
+    Version version = new Version(1, 0);
+    version.setBaseId(baseId);
+    version.setName("version name");
+    version.setDescription("version description");
+    version.setStatus(VersionStatus.Draft);
+
+    doReturn(new Id("versionId")).when(zusammenAdaptorMock)
+        .createVersion(eq(createZusammenContext()), eq(new Id(itemId)),
+            baseId == null ? isNull(Id.class) : eq(new Id(baseId)), any(ItemVersionData.class));
+
+    ArgumentCaptor<ItemVersionData> capturedZusammenVersion =
+        ArgumentCaptor.forClass(ItemVersionData.class);
+
+    versionDao.create(itemId, version);
+
+    verify(zusammenAdaptorMock)
+        .createVersion(eq(createZusammenContext()), eq(new Id(itemId)),
+            baseId == null ? isNull(Id.class) : eq(new Id(baseId)),
+            capturedZusammenVersion.capture());
+
+    Info capturedInfo = capturedZusammenVersion.getValue().getInfo();
+    Assert.assertEquals(capturedInfo.getName(), version.getName());
+    Assert.assertEquals(capturedInfo.getDescription(), version.getDescription());
+    Assert.assertEquals(VersionStatus
+            .valueOf(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS)),
+        version.getStatus());
+    Assert.assertEquals(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL),
+        version.toString());
+  }
+
+  @Test
+  public void testUpdate() throws Exception {
+    String itemId = "itemId";
+    Version version = new Version(1, 0);
+    version.setId("versionId");
+    version.setBaseId("baseId");
+    version.setName("version name");
+    version.setDescription("version description");
+    version.setStatus(VersionStatus.Certified);
+
+    ArgumentCaptor<ItemVersionData> capturedZusammenVersion =
+        ArgumentCaptor.forClass(ItemVersionData.class);
+
+    versionDao.update(itemId, version);
+
+    verify(zusammenAdaptorMock)
+        .updateVersion(eq(createZusammenContext()), eq(new Id(itemId)), eq(new Id(version.getId())),
+            capturedZusammenVersion.capture());
+
+    Info capturedInfo = capturedZusammenVersion.getValue().getInfo();
+    Assert.assertEquals(capturedInfo.getName(), version.getName());
+    Assert.assertEquals(capturedInfo.getDescription(), version.getDescription());
+    Assert.assertEquals(VersionStatus
+            .valueOf(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS)),
+        version.getStatus());
+    Assert.assertEquals(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL),
+        version.toString());
+  }
+
+  @Test
+  public void testGetNonExisting() throws Exception {
+    Optional<Version> version = versionDao.get("itemId", new Version("versionId"));
+
+    Assert.assertEquals(version, Optional.empty());
+  }
+
+  @Test
+  public void testGet() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+
+    SessionContext zusammenContext = createZusammenContext();
+    Id itemIdObj = new Id(itemId);
+    Id versionIdObj = new Id(versionId);
+
+    ItemVersion zusammenPrivateVersion =
+        createZusammenVersion(versionIdObj, new Id("baseId"), "version desc  updated", "2.0",
+            VersionStatus.Draft);
+    doReturn(zusammenPrivateVersion).when(zusammenAdaptorMock)
+        .getVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+    doReturn(new ItemVersionStatus(SynchronizationStatus.UP_TO_DATE, true))
+        .when(zusammenAdaptorMock)
+        .getVersionStatus(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+    ItemVersion zusammenPublicVersion =
+        createZusammenVersion(versionIdObj, new Id("baseId"), "version desc", "2.0",
+            VersionStatus.Certified);
+    doReturn(zusammenPublicVersion).when(zusammenAdaptorMock)
+        .getPublicVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
+
+    Optional<Version> version = versionDao.get(itemId, new Version(versionId));
+
+    Assert.assertTrue(version.isPresent());
+    zusammenPrivateVersion.getData().getInfo()
+        .addProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS,
+            VersionStatus.Certified.name());
+    assetVersionEquals(version.get(), zusammenPrivateVersion);
+  }
+
+  // TODO: 12/20/2017 complete tests
+ /* @Test
+  public void testDelete() throws Exception {
+
+  }
+
+  @Test
+  public void testPublish() throws Exception {
+
+  }
+
+  @Test
+  public void testSync() throws Exception {
+
+  }
+
+  @Test
+  public void testForceSync() throws Exception {
+
+  }
+
+  @Test
+  public void testRevert() throws Exception {
+
+  }
+
+  @Test
+  public void testListRevisions() throws Exception {
+
+  }*/
+
+  private void assetVersionEquals(Version version, ItemVersion zusammenVersion) {
+    Assert.assertEquals(version.getId(), zusammenVersion.getId().getValue());
+    Assert.assertEquals(version.getBaseId(),
+        zusammenVersion.getBaseId() == null ? null : zusammenVersion.getBaseId().getValue());
+    Info info = zusammenVersion.getData().getInfo();
+    Assert.assertEquals(version.getName(), info.getName());
+    Assert.assertEquals(version.getDescription(), info.getDescription());
+    Assert.assertEquals(version.getStatus(),
+        VersionStatus.valueOf(info.getProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS)));
+    String label = info.getProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL).toString();
+    Assert
+        .assertEquals(version.getMajor(), Integer.parseInt(label.substring(0, label.indexOf('.'))));
+    Assert.assertEquals(version.getMinor(),
+        Integer.parseInt(label.substring(label.indexOf('.') + 1, label.length())));
+    Assert.assertEquals(version.getCreationTime(), zusammenVersion.getCreationTime());
+    Assert.assertEquals(version.getModificationTime(), zusammenVersion.getModificationTime());
+  }
+
+  private ItemVersion createZusammenVersion(Id id, Id baseId, String description, String label,
+                                            VersionStatus status) {
+    ItemVersion version = new ItemVersion();
+    version.setId(id);
+    version.setBaseId(baseId);
+    Info info = new Info();
+    info.setName(id + "_name");
+    info.setDescription(description);
+    info.addProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL, label);
+    info.addProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS, status.name());
+    ItemVersionData data = new ItemVersionData();
+    data.setInfo(info);
+    version.setData(data);
+    version.setCreationTime(new Date());
+    version.setModificationTime(new Date());
+    return version;
+  }
+
+  private SessionContext createZusammenContext() {
+    SessionContext sessionContext = new SessionContext();
+    sessionContext.setUser(new UserInfo(USER));
+    sessionContext.setTenant("dox");
+    return sessionContext;
+  }
+
+}
+\ No newline at end of file
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/ItemManagerImplTest.java
new file mode 100644
index 0000000000..755bfb4442
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/ItemManagerImplTest.java
@@ -0,0 +1,124 @@
+package org.openecomp.sdc.versioning.impl;
+
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+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.dao.ItemDao;
+import org.openecomp.sdc.versioning.dao.types.VersionStatus;
+import org.openecomp.sdc.versioning.types.Item;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+public class ItemManagerImplTest {
+
+  @Mock
+  private ItemDao itemDao;
+  @Mock
+  private PermissionsServices permissionsServices;
+  @Mock
+  private SubscriptionService subscriptionService;
+  @InjectMocks
+  private ItemManagerImpl itemManager;
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  public void testList() throws Exception {
+    doReturn(Stream.of(
+        createItem("item1", "A"),
+        createItem("item2", "B"),
+        createItem("item3", "B"),
+        createItem("item4", "A"))
+        .collect(Collectors.toList())).when(itemDao).list();
+
+    Collection<Item> items = itemManager.list(item -> "B".equals(item.getType()));
+    Assert.assertEquals(items.size(), 2);
+    Assert.assertTrue(items.stream().anyMatch(item -> "item2".equals(item.getName())));
+    Assert.assertTrue(items.stream().anyMatch(item -> "item3".equals(item.getName())));
+  }
+
+  @Test
+  public void testGetNotExisting() throws Exception {
+    Item item = itemManager.get("item1");
+    Assert.assertNull(item);
+  }
+
+  @Test
+  public void testGet() throws Exception {
+    Item toBeReturned = new Item();
+    toBeReturned.setId("itemId");
+    doReturn(toBeReturned).when(itemDao).get(any(Item.class));
+
+    Item item = itemManager.get("itemId");
+    Assert.assertEquals(item.getId(), "itemId");
+  }
+
+  @Test
+  public void testCreate() throws Exception {
+    SessionContextProviderFactory.getInstance().createInterface().create("user1");
+
+    Item toBeReturned = new Item();
+    toBeReturned.setId("itemId");
+    doReturn(toBeReturned).when(itemDao).create(any(Item.class));
+
+    Item item = itemManager.create(createItem("item1", "A"));
+    Assert.assertEquals(item.getId(), "itemId");
+  }
+
+  @Test
+  public void testUpdateNotExistingVersionStatus() throws Exception {
+    itemManager.updateVersionStatus("itemId", VersionStatus.Certified, VersionStatus.Draft);
+    verify(itemDao, never()).update(any(Item.class));
+  }
+
+  @Test
+  public void testUpdateVersionStatusWhenNone() throws Exception {
+    Item item = new Item();
+    item.setId("itemId");
+    doReturn(item).when(itemDao).get(any(Item.class));
+
+    itemManager.updateVersionStatus("itemId", VersionStatus.Certified, VersionStatus.Draft);
+    verify(itemDao).update(item);
+    Assert.assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 1);
+    Assert.assertNull(item.getVersionStatusCounters().get(VersionStatus.Draft));
+  }
+
+  @Test
+  public void testUpdateVersionStatus() throws Exception {
+    Item item = new Item();
+    item.setId("itemId");
+    item.getVersionStatusCounters().put(VersionStatus.Certified, 2);
+    item.getVersionStatusCounters().put(VersionStatus.Draft, 5);
+    doReturn(item).when(itemDao).get(any(Item.class));
+
+    itemManager.updateVersionStatus("itemId", VersionStatus.Certified, VersionStatus.Draft);
+    verify(itemDao).update(item);
+    Assert.assertEquals(item.getVersionStatusCounters().get(VersionStatus.Certified).intValue(), 3);
+    Assert.assertEquals(item.getVersionStatusCounters().get(VersionStatus.Draft).intValue(), 4);
+  }
+
+  private Item createItem(String name, String type) {
+    Item item = new Item();
+    item.setId(name);
+    item.setName(name);
+    item.setType(type);
+    return item;
+  }
+
+}
+\ No newline at end of file
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 d35de4f3d1..2d1109abe6 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
@@ -21,39 +21,326 @@
 package org.openecomp.sdc.versioning.impl;
 
 
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.verify;
-
 import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.versioning.dao.VersionInfoDao;
-import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
-import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
+import org.openecomp.sdc.versioning.ItemManager;
+import org.openecomp.sdc.versioning.VersionCalculator;
+import org.openecomp.sdc.versioning.dao.VersionDao;
+import org.openecomp.sdc.versioning.dao.types.Revision;
+import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
 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.VersionState;
 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.VersionCreationMethod;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.OutOfSync;
+import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.UpToDate;
+import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
+import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
 
 public class VersioningManagerImplTest {
+  @Mock
+  private VersionDao versionDaoMock;
+  @Mock
+  private VersionCalculator versionCalculatorMock;
+  @Mock
+  private ItemManager itemManagerMock;
+  @InjectMocks
+  private VersioningManagerImpl versioningManager;
+
+  @BeforeMethod
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  public void testList() throws Exception {
+    String itemId = "itemId";
+
+    List<Version> returnedVersions = Stream.of(createVersion("1", null, null, false),
+        createVersion("2", null, null, false),
+        createVersion("3", null, null, false)).collect(Collectors.toList());
+    doReturn(returnedVersions).when(versionDaoMock).list(itemId);
+
+    List<Version> versions = versioningManager.list(itemId);
+    Assert.assertEquals(versions, returnedVersions);
+  }
+
+  @Test(expectedExceptions = Exception.class)
+  public void testGetNonExisting() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+
+    doReturn(Optional.empty()).when(versionDaoMock).get(itemId, version);
+    doThrow(new Exception()).when(versionDaoMock).sync(itemId, version);
+
+    versioningManager.get(itemId, version);
+  }
+
+  @Test
+  public void testGetNonExistingForUser() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version requestedVersion = new Version(versionId);
+
+    Version returnedVersion = createVersion(versionId, Draft, UpToDate, false);
+    doReturn(Optional.empty()).doReturn(Optional.of(returnedVersion))
+        .when(versionDaoMock).get(itemId, requestedVersion);
+
+    Version version = versioningManager.get(itemId, requestedVersion);
+    Assert.assertEquals(version, returnedVersion);
+
+    verify(versionDaoMock, times(2)).get(itemId, requestedVersion);
+    verify(versionDaoMock).sync(itemId, requestedVersion);
+  }
+
+  @Test
+  public void testGetOutOfSyncCertified() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version requestedVersion = new Version(versionId);
+
+    Version returnedVersion = createVersion(versionId, Certified, UpToDate, false);
+    doReturn(Optional.of(createVersion(versionId, Certified, OutOfSync, false)))
+        .doReturn(Optional.of(returnedVersion))
+        .when(versionDaoMock).get(itemId, requestedVersion);
+
+    Version version = versioningManager.get(itemId, requestedVersion);
+    Assert.assertEquals(version, returnedVersion);
+
+    verify(versionDaoMock, times(2)).get(itemId, requestedVersion);
+    verify(versionDaoMock).forceSync(itemId, requestedVersion);
+  }
+
+  @Test
+  public void testGet() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version requestedVersion = new Version(versionId);
+
+    Version returnedVersion = createVersion(versionId, Draft, OutOfSync, true);
+    doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(itemId, requestedVersion);
+
+    Version version = versioningManager.get(itemId, requestedVersion);
+    Assert.assertEquals(version, returnedVersion);
+
+    verify(versionDaoMock).get(itemId, requestedVersion);
+    verify(versionDaoMock, never()).sync(any(), any());
+    verify(versionDaoMock, never()).forceSync(any(), any());
+  }
+
+  @Test
+  public void testCreate() throws Exception {
+    String itemId = "itemId";
+    Version requestedVersion = new Version();
+
+    String versionName = "versionName";
+    doReturn(versionName).when(versionCalculatorMock).calculate(null, VersionCreationMethod.major);
+
+    doReturn(Stream.of(createVersion("1", null, null, false),
+        createVersion("2", null, null, false),
+        createVersion("3", null, null, false)).collect(Collectors.toList()))
+        .when(versionDaoMock).list(itemId);
+
+    Version version =
+        versioningManager.create(itemId, requestedVersion, VersionCreationMethod.major);
+    Assert.assertNotNull(version);
+    Assert.assertEquals(version.getName(), versionName);
+
+    verify(versionDaoMock).create(itemId, requestedVersion);
+    verify(itemManagerMock).updateVersionStatus(itemId, Draft, null);
+    verify(versionDaoMock).publish(eq(itemId), eq(requestedVersion), anyString());
+  }
+
+  @Test
+  public void testCreateBasedOn() throws Exception {
+    String itemId = "itemId";
+    Version requestedVersion = new Version();
+    requestedVersion.setBaseId("baseVersionId");
+
+    Version baseVersion = createVersion(requestedVersion.getBaseId(), Certified, UpToDate, false);
+    // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
+    doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(itemId), any(Version.class));
+
+    String versionName = "4.0";
+    doReturn(versionName)
+        .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
+
+    doReturn(Stream.of(createVersion("1", null, null, false),
+        createVersion("2", null, null, false),
+        createVersion("3", null, null, false)).collect(Collectors.toList()))
+        .when(versionDaoMock).list(itemId);
+
+    Version version =
+        versioningManager.create(itemId, requestedVersion, VersionCreationMethod.major);
+    Assert.assertNotNull(version);
+    Assert.assertEquals(version.getName(), versionName);
+
+    verify(versionDaoMock).create(itemId, requestedVersion);
+    verify(itemManagerMock).updateVersionStatus(itemId, Draft, null);
+    verify(versionDaoMock).publish(eq(itemId), eq(requestedVersion), anyString());
+  }
+
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp =
+      "Item itemId: create version failed, a version with the name 2.0 already exist")
+  public void testCreateWithExistingName() throws Exception {
+    String itemId = "itemId";
+    Version version = new Version();
+    version.setBaseId("baseVersionId");
+
+    Version baseVersion = createVersion(version.getBaseId(), Certified, UpToDate, false);
+    // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
+    doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(itemId), any(Version.class));
+
+    String versionName = "2.0";
+    doReturn(versionName)
+        .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
+
+    doReturn(Stream.of(createVersion("1", null, null, false),
+        createVersion("2", null, null, false),
+        createVersion("3", null, null, false)).collect(Collectors.toList()))
+        .when(versionDaoMock).list(itemId);
+
+    versioningManager.create(itemId, version, VersionCreationMethod.major);
+  }
+
+  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp =
+      "Item itemId: submit version failed, version versionId is already Certified")
+  public void testSubmitCertified() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+
+    Version returnedVersion = createVersion(versionId, Certified, UpToDate, false);
+    doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(itemId, version);
+
+    versioningManager.submit(itemId, version, "Submit message");
+  }
+
+  @Test
+  public void testSubmit() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+
+    ArgumentCaptor<Version> versionArgumentCaptor = ArgumentCaptor.forClass(Version.class);
+
+    Version returnedVersion = createVersion(versionId, Draft, UpToDate, false);
+    doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(itemId, version);
+
+    String submitDescription = "Submit message";
+    versioningManager.submit(itemId, version, submitDescription);
+
+    verify(versionDaoMock).update(eq(itemId), versionArgumentCaptor.capture());
+    Assert.assertEquals(Certified, versionArgumentCaptor.getValue().getStatus());
+    verify(versionDaoMock).publish(itemId, version, submitDescription);
+    verify(itemManagerMock).updateVersionStatus(itemId, Certified, Draft);
+  }
+
+  @Test
+  public void testPublish() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+    String publishDescription = "Publish message";
+
+    versioningManager.publish(itemId, version, publishDescription);
+
+    verify(versionDaoMock).publish(itemId, version, publishDescription);
+  }
+
+  @Test
+  public void testSync() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+
+    versioningManager.sync(itemId, version);
+
+    verify(versionDaoMock).sync(itemId, version);
+  }
+
+  @Test
+  public void testForceSync() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+
+    versioningManager.forceSync(itemId, version);
+
+    verify(versionDaoMock).forceSync(itemId, version);
+  }
+
+  @Test
+  public void testRevert() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+    String revisionId = "revisionId";
+
+    versioningManager.revert(itemId, version, revisionId);
+
+    verify(versionDaoMock).revert(itemId, version, revisionId);
+  }
+
+  @Test
+  public void testListRevisions() throws Exception {
+    String itemId = "itemId";
+    String versionId = "versionId";
+    Version version = new Version(versionId);
+
+    List<Revision> returnedRevisions =
+        Stream.of(new Revision(), new Revision()).collect(Collectors.toList());
+    doReturn(returnedRevisions)
+        .when(versionDaoMock).listRevisions(itemId, version);
+
+    List<Revision> revisions = versioningManager.listRevisions(itemId, version);
+    Assert.assertEquals(revisions, returnedRevisions);
+  }
+
+  private Version createVersion(String id, VersionStatus status,
+                                SynchronizationState syncState, boolean dirty) {
+    Version version = new Version(id);
+    version.setName(id + ".0");
+    version.setDescription(id + " desc");
+    version.setStatus(status);
+
+    VersionState state = new VersionState();
+    state.setSynchronizationState(syncState);
+    state.setDirty(dirty);
+    version.setState(state);
+    return version;
+  }
+
+/*
   private static final String USR1 = "usr1";
   private static final String USR2 = "usr2";
   private static final String TYPE1 = "Type1";
-/*  private static final String TYPE2 = "Type2";*/
+*/
+/*  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";
@@ -61,17 +348,20 @@ public class VersioningManagerImplTest {
   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 String TYPE2_VERSION_NAME = "version";*//*
+
   private static final Version VERSION0 = new Version(0, 0);
   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 final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+  */
+/*  private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
 
     private static UDTMapper<Version> versionMapper =
-        noSqlDb.getMappingManager().udtMapper(Version.class);*/
+        noSqlDb.getMappingManager().udtMapper(Version.class);*//*
+
   @Mock
   private VersionInfoDao versionInfoDaoMock;
   @Mock
@@ -87,7 +377,8 @@ public class VersioningManagerImplTest {
     MockitoAnnotations.initMocks(this);
   }
 
-  /*  @BeforeClass
+  */
+/*  @BeforeClass
     private void init() {
       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID1));
       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID2));
@@ -103,8 +394,10 @@ public class VersioningManagerImplTest {
           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 testRegister() throws Exception {
     VersionableEntityMetadata entityMetadata =
@@ -116,7 +409,8 @@ public class VersioningManagerImplTest {
     Set<VersionableEntityMetadata> type1Entities = versionableEntities.get(TYPE1);
     Assert.assertNotNull(type1Entities);
     Assert.assertTrue(type1Entities.contains(entityMetadata));
-  }*/
+  }*//*
+
 
   @Test(expectedExceptions = CoreException.class)
   public void testCreateAlreadyExisting() {
@@ -129,8 +423,10 @@ public class VersioningManagerImplTest {
     Version version = versioningManager.create(TYPE1, ID1, USR1);
     Assert.assertEquals(version, VERSION01);
 
+*/
 /*    createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
-        version);*/
+        version);*//*
+
     verify(versionInfoDaoMock).create(versionInfoEntityArg.capture());
     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1,
@@ -152,7 +448,7 @@ public class VersioningManagerImplTest {
   @Test
   public void testDelete() {
     VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
-    versionInfoEntity.setStatus(VersionStatus.Available);
+    versionInfoEntity.setStatus(VersionStatus.Draft);
     doReturn(versionInfoEntity).when(versionInfoDaoMock).get(anyObject());
 
     versioningManager.delete(TYPE1, ID1, USR1);
@@ -171,13 +467,14 @@ public class VersioningManagerImplTest {
   @Test
   public void testUndoDelete() {
     VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity();
-    versionInfoDeletedEntity.setStatus(VersionStatus.Available);
+    versionInfoDeletedEntity.setStatus(VersionStatus.Draft);
     doReturn(versionInfoDeletedEntity).when(versionInfoDeletedDaoMock).get(anyObject());
 
     versioningManager.undoDelete(TYPE1, ID1, USR1);
 
     verify(versionInfoDeletedDaoMock).delete(versionInfoDeletedEntity);
     verify(versionInfoDaoMock).create(versionInfoEntityArg.capture());
+*/
 /*
     VersionInfoDeletedEntity versionInfoDeletedEntity =
         versionInfoDeletedDaoMock.get(new VersionInfoDeletedEntity(TYPE1, ID1));
@@ -190,7 +487,8 @@ public class VersioningManagerImplTest {
     Assert.assertNull(versionInfoEntity);
     versioningManager.undoDelete(TYPE1, ID1, USR1);
     versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
-    Assert.assertNotNull(versionInfoEntity);*/
+    Assert.assertNotNull(versionInfoEntity);*//*
+
   }
 
   @Test(expectedExceptions = CoreException.class)
@@ -216,7 +514,7 @@ public class VersioningManagerImplTest {
   public void testCheckoutOnFinalized() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION10);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
         VERSION10);
 
     Version version = versioningManager.checkout(TYPE1, ID1, USR1);
@@ -225,18 +523,20 @@ public class VersioningManagerImplTest {
     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR1,
         VersionStatus.Locked, viewableVersions, VERSION10);
+*/
 /*
     ResultSet results =
         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
             VERSION11);
-    Assert.assertTrue(results.iterator().hasNext());*/
+    Assert.assertTrue(results.iterator().hasNext());*//*
+
   }
 
   @Test
   public void testCheckout() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION01);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
         null);
 
     Version version = versioningManager.checkout(TYPE1, ID1, USR1);
@@ -248,10 +548,12 @@ public class VersioningManagerImplTest {
     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR1,
         VersionStatus.Locked, viewableVersions, null);
 
+*/
 /*    ResultSet results =
         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
             VERSION02);
-    Assert.assertTrue(results.iterator().hasNext());*/
+    Assert.assertTrue(results.iterator().hasNext());*//*
+
   }
 
   @Test(expectedExceptions = CoreException.class)
@@ -263,7 +565,7 @@ public class VersioningManagerImplTest {
   public void testUndoCheckoutOnAvailable() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION01);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
         null);
 
     versioningManager.undoCheckout(TYPE1, ID1, USR1);
@@ -273,7 +575,7 @@ public class VersioningManagerImplTest {
   public void testUndoCheckouOnFinalized() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION10);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
         VERSION10);
     versioningManager.undoCheckout(TYPE1, ID1, USR2);
   }
@@ -298,12 +600,14 @@ public class VersioningManagerImplTest {
 
     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
-        VersionStatus.Available, viewableVersions, null);
+        VersionStatus.Draft, viewableVersions, null);
 
+*/
 /*    ResultSet results =
         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
             VERSION02);
-    Assert.assertFalse(results.iterator().hasNext());*/
+    Assert.assertFalse(results.iterator().hasNext());*//*
+
   }
 
   @Test(expectedExceptions = CoreException.class)
@@ -315,7 +619,7 @@ public class VersioningManagerImplTest {
   public void testCheckinOnAvailable() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION01);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
         null);
 
     versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin");
@@ -326,7 +630,7 @@ public class VersioningManagerImplTest {
   public void testCheckinOnFinalized() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION10);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
         VERSION10);
 
     versioningManager.checkin(TYPE1, ID1, USR1, "failed checkin");
@@ -354,7 +658,7 @@ public class VersioningManagerImplTest {
 
     viewableVersions.add(VERSION01);
     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
-        VersionStatus.Available, viewableVersions, null);
+        VersionStatus.Draft, viewableVersions, null);
   }
 
   @Test(expectedExceptions = CoreException.class)
@@ -374,7 +678,7 @@ public class VersioningManagerImplTest {
   public void testSubmitOnFinalized() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION10);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
         VERSION10);
     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
   }
@@ -390,7 +694,7 @@ public class VersioningManagerImplTest {
     viewableVersions.add(new Version(3, 0));
     viewableVersions.add(new Version(3, 1));
     viewableVersions.add(version32);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, version32, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, version32, null, viewableVersions,
         new Version(3, 0));
 
     Version version = versioningManager.submit(TYPE1, ID1, USR1, "submit msg");
@@ -403,12 +707,14 @@ public class VersioningManagerImplTest {
     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 
     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, version40, null, null,
-        VersionStatus.Final, viewableVersions, version40);
+        VersionStatus.Certified, viewableVersions, version40);
 
+*/
 /*    ResultSet results =
         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
             VERSION10);
-    Assert.assertTrue(results.iterator().hasNext());*/
+    Assert.assertTrue(results.iterator().hasNext());*//*
+
   }
 
   @Test(expectedExceptions = CoreException.class)
@@ -420,12 +726,12 @@ public class VersioningManagerImplTest {
   public void testGetVersionInfoForReadOnAvailable() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION01);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
         null);
 
     VersionInfo versionInfo =
         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
-    assertVersionInfo(versionInfo, VERSION01, VersionStatus.Available, null,
+    assertVersionInfo(versionInfo, VERSION01, VersionStatus.Draft, null,
         viewableVersions, null);
   }
 
@@ -433,7 +739,7 @@ public class VersioningManagerImplTest {
   public void testGetVersionInfoForWriteOnAvailable() {
     Set<Version> viewableVersions = new HashSet<>();
     viewableVersions.add(VERSION01);
-    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
+    mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
         null);
 
     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write);
@@ -488,6 +794,7 @@ public class VersioningManagerImplTest {
     assertVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR1, viewableVersions, null);
   }
 
+*/
 /*  private void createVersionableEntityRecord(String tableName, String idName, String versionName,
                                              String id, Version version) {
     noSqlDb.execute(
@@ -500,7 +807,8 @@ public class VersioningManagerImplTest {
     return noSqlDb.execute(
         String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id,
         versionMapper.toUDT(version));
-  }*/
+  }*//*
+
 
 
   private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType,
@@ -553,4 +861,5 @@ public class VersioningManagerImplTest {
     doReturn(mock).when(versionInfoDaoMock).get(anyObject());
     return mock;
   }
+*/
 }
author	talig <talig@amdocs.com>	2017-12-20 14:30:43 +0200
committer	Vitaly Emporopulo <Vitaliy.Emporopulo@amdocs.com>	2017-12-21 11:12:33 +0000
commit	8e9c0653dd6c6862123c9609ae34e1206d86456e (patch)
tree	5eeef00ec0677133baa439ca8d7ffd7aca4804b6 /openecomp-be/lib/openecomp-sdc-versioning-lib
parent	785ebcc95de3e064e843bec04ba7a209d854fc7c (diff)