Add collaboration feature

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

21 files changed, 1950 insertions, 229 deletions

diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/CommitStagingService.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/CommitStagingService.java
new file mode 100644
index 0000000000..45d5769e9c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/CommitStagingService.java
@@ -0,0 +1,100 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.StageEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Collection;
+import java.util.Optional;
+
+public class CommitStagingService {
+
+  private VersionPrivateStore versionPrivateStore;
+  private VersionStageStore versionStageStore;
+  private ElementPrivateStore elementPrivateStore;
+  private ElementStageStore elementStageStore;
+
+  public CommitStagingService(VersionPrivateStore versionPrivateStore,
+                              VersionStageStore versionStageStore,
+                              ElementPrivateStore elementPrivateStore,
+                              ElementStageStore elementStageStore) {
+    this.versionPrivateStore = versionPrivateStore;
+    this.versionStageStore = versionStageStore;
+    this.elementPrivateStore = elementPrivateStore;
+    this.elementStageStore = elementStageStore;
+  }
+
+  public void commitStaging(SessionContext context, Id itemId, Id versionId) {
+    Optional<StageEntity<VersionEntity>> versionStage =
+        versionStageStore.get(context, itemId, new VersionEntity(versionId));
+
+    final ElementContext elementContext = new ElementContext(itemId, versionId, Id.ZERO);
+    Collection<ElementEntity> stagedElementIds = elementStageStore.listIds(context, elementContext);
+
+    if ((!versionStage.isPresent() && stagedElementIds.isEmpty()) ||
+        elementStageStore.hasConflicts(context, elementContext)) {
+      return;
+    }
+
+    versionStage.ifPresent(verStage -> commitVersionStage(context, itemId, verStage));
+    commitElementsStage(context, elementContext, stagedElementIds);
+  }
+
+  private void commitVersionStage(SessionContext context, Id itemId,
+                                  StageEntity<VersionEntity> versionStage) {
+    switch (versionStage.getAction()) {
+      case CREATE:
+        versionPrivateStore.commitStagedCreate(context, itemId, versionStage.getEntity(),
+            versionStage.getPublishTime());
+        break;
+      case UPDATE:
+        versionPrivateStore.commitStagedUpdate(context, itemId, versionStage.getEntity(),
+            versionStage.getPublishTime());
+        break;
+      case IGNORE:
+        versionPrivateStore.commitStagedIgnore(context, itemId, versionStage.getEntity(),
+            versionStage.getPublishTime());
+        break;
+      default:
+        throw new UnsupportedOperationException(
+            "Version change other then Create/Update/Ignore is not supported");
+    }
+
+    versionStageStore.delete(context, itemId, versionStage.getEntity());
+  }
+
+  private void commitElementsStage(SessionContext context, ElementContext elementContext,
+                                   Collection<ElementEntity> stagedElementIds) {
+    for (ElementEntity stagedElementId : stagedElementIds) {
+      StageEntity<ElementEntity> stagedElement =
+          elementStageStore.get(context, elementContext, stagedElementId)
+              .orElseThrow(
+                  () -> new IllegalStateException("Element id returned by list must exist"));
+      switch (stagedElement.getAction()) {
+        case CREATE:
+          elementPrivateStore.commitStagedCreate(context, elementContext, stagedElement.getEntity(),
+              stagedElement.getPublishTime());
+          break;
+        case UPDATE:
+          elementPrivateStore.commitStagedUpdate(context, elementContext, stagedElement.getEntity(),
+              stagedElement.getPublishTime());
+          break;
+        case DELETE:
+          elementPrivateStore
+              .commitStagedDelete(context, elementContext, stagedElement.getEntity());
+          break;
+        case IGNORE:
+          elementPrivateStore.commitStagedIgnore(context, elementContext, stagedElement.getEntity(),
+              stagedElement.getPublishTime());
+          break;
+        default:
+          throw new UnsupportedOperationException(
+              "Element change other then Create/Update/Delete/Ignore is not supported");
+      }
+      elementStageStore.delete(context, elementContext, stagedElement.getEntity());
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementCollaborationStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementCollaborationStore.java
deleted file mode 100644
index ac103c0fbf..0000000000
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementCollaborationStore.java
+++ /dev/null
@@ -1,119 +0,0 @@
-package org.openecomp.core.zusammen.plugin.collaboration;
-
-import com.amdocs.zusammen.datatypes.Id;
-import com.amdocs.zusammen.datatypes.SessionContext;
-import com.amdocs.zusammen.datatypes.item.ElementContext;
-import com.amdocs.zusammen.plugin.statestore.cassandra.dao.types.ElementEntityContext;
-import com.amdocs.zusammen.sdk.collaboration.types.CollaborationElement;
-import org.openecomp.core.zusammen.plugin.ZusammenPluginConstants;
-import org.openecomp.core.zusammen.plugin.ZusammenPluginUtil;
-import org.openecomp.core.zusammen.plugin.dao.ElementRepository;
-import org.openecomp.core.zusammen.plugin.dao.ElementRepositoryFactory;
-import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Optional;
-
-import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getCollaborationElement;
-import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getSpaceName;
-
-
-public class ElementCollaborationStore {
-
-  private static final String SUB_ELEMENT_NOT_EXIST_ERROR_MSG =
-      "List sub elements error: item %s, version %s - " +
-          "element %s, which appears as sub element of element %s, does not exist";
-
-  public Collection<CollaborationElement> listElements(SessionContext context,
-                                                       ElementContext elementContext,
-                                                       Id elementId) {
-    ElementEntityContext elementEntityContext =
-        new ElementEntityContext(ZusammenPluginUtil.getPrivateSpaceName(context), elementContext);
-
-    if (elementId == null) {
-      elementId = ZusammenPluginConstants.ROOT_ELEMENTS_PARENT_ID;
-    }
-
-    ElementRepository elementRepository = getElementRepository(context);
-    String elementIdValue = elementId.getValue();
-    String versionIdValue = elementContext.getChangeRef() == null
-        ? elementContext.getVersionId().getValue()
-        : elementContext.getChangeRef();
-    Collection<CollaborationElement> subElements = new ArrayList<>();
-
-    Optional<ElementEntity> element =
-        elementRepository.get(context, elementEntityContext, new ElementEntity(elementId));
-    if (element.isPresent() && element.get().getSubElementIds() != null) {
-      for (Id subElementId : element.get().getSubElementIds()) {
-        ElementEntity subElement =
-            elementRepository.get(context, elementEntityContext, new ElementEntity(subElementId))
-                .orElseThrow(
-                    () -> new IllegalStateException(String.format(SUB_ELEMENT_NOT_EXIST_ERROR_MSG,
-                        elementContext.getItemId().getValue(), versionIdValue,
-                        subElementId.getValue(), elementIdValue)));
-        subElements.add(getCollaborationElement(elementEntityContext, subElement));
-      }
-    }
-    return subElements;
-  }
-
-  public CollaborationElement getElement(SessionContext context, ElementContext elementContext,
-                                         Id elementId) {
-    ElementEntityContext elementEntityContext =
-        new ElementEntityContext(ZusammenPluginUtil.getPrivateSpaceName(context), elementContext);
-    return getElementRepository(context)
-        .get(context, elementEntityContext, new ElementEntity(elementId))
-        .map(elementEntity -> getCollaborationElement(elementEntityContext, elementEntity))
-        .orElse(null);
-  }
-
-  public void createElement(SessionContext context, CollaborationElement element) {
-    getElementRepository(context)
-        .create(context,
-            new ElementEntityContext(getSpaceName(context, element.getSpace()),
-                element.getItemId(), element.getVersionId()),
-            ZusammenPluginUtil.getElementEntity(element));
-  }
-
-  public void updateElement(SessionContext context, CollaborationElement element) {
-    getElementRepository(context)
-        .update(context,
-            new ElementEntityContext(getSpaceName(context, element.getSpace()),
-                element.getItemId(), element.getVersionId()),
-            ZusammenPluginUtil.getElementEntity(element));
-  }
-
-  public void deleteElement(SessionContext context, CollaborationElement element) {
-    deleteElementHierarchy(getElementRepository(context),
-        context,
-        new ElementEntityContext(getSpaceName(context, element.getSpace()),
-            element.getItemId(), element.getVersionId()),
-        ZusammenPluginUtil.getElementEntity(element));
-  }
-
-  public boolean checkHealth(SessionContext sessionContext) {
-    return getElementRepository(sessionContext).checkHealth(sessionContext);
-  }
-
-  private void deleteElementHierarchy(ElementRepository elementRepository, SessionContext context,
-                                      ElementEntityContext elementEntityContext,
-                                      ElementEntity elementEntity) {
-    Optional<ElementEntity> retrieved =
-        elementRepository.get(context, elementEntityContext, elementEntity);
-    if (!retrieved.isPresent()) {
-      return;
-    }
-    retrieved.get().getSubElementIds().stream()
-        .map(ElementEntity::new)
-        .forEach(subElementEntity -> deleteElementHierarchy(
-            elementRepository, context, elementEntityContext, subElementEntity));
-
-    // only for the first one the parentId will populated (so it'll be removed from its parent)
-    elementRepository.delete(context, elementEntityContext, elementEntity);
-  }
-
-  protected ElementRepository getElementRepository(SessionContext context) {
-    return ElementRepositoryFactory.getInstance().createInterface(context);
-  }
-}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementPrivateStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementPrivateStore.java
new file mode 100644
index 0000000000..045def2561
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementPrivateStore.java
@@ -0,0 +1,48 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.Map;
+import java.util.Optional;
+
+public interface ElementPrivateStore extends ElementStore {
+
+  Map<Id, Id> listIds(SessionContext context, ElementContext elementContext);
+
+  Collection<ElementEntity> listSubs(SessionContext context, ElementContext elementContext,
+                                     Id elementId);
+
+  Optional<SynchronizationStateEntity> getSynchronizationState(SessionContext context,
+                                                               ElementContext elementContext,
+                                                               Id elementId);
+
+  void create(SessionContext context, ElementContext elementContext, ElementEntity element);
+
+  boolean update(SessionContext context, ElementContext elementContext, ElementEntity element);
+
+  void delete(SessionContext context, ElementContext elementContext, ElementEntity element);
+
+  void markAsPublished(SessionContext context, ElementContext elementContext, Id elementId,
+                       Date publishTime);
+
+  void markDeletionAsPublished(SessionContext context, ElementContext elementContext, Id elementId,
+                               Date publishTime);
+
+  void commitStagedCreate(SessionContext context, ElementContext elementContext,
+                          ElementEntity element, Date publishTime);
+
+  void commitStagedUpdate(SessionContext context, ElementContext elementContext,
+                          ElementEntity element, Date publishTime);
+
+  void commitStagedDelete(SessionContext context, ElementContext elementContext,
+                          ElementEntity element);
+
+  void commitStagedIgnore(SessionContext context, ElementContext elementContext,
+                          ElementEntity element, Date publishTime);
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementPublicStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementPublicStore.java
new file mode 100644
index 0000000000..0f1790a1bf
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementPublicStore.java
@@ -0,0 +1,23 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+
+import java.util.Date;
+import java.util.Map;
+
+public interface ElementPublicStore extends ElementStore {
+
+  void create(SessionContext context, ElementContext elementContext, ElementEntity element,
+              Date publishTime);
+
+  void update(SessionContext context, ElementContext elementContext, ElementEntity element,
+              Date publishTime);
+
+  void delete(SessionContext context, ElementContext elementContext, ElementEntity element,
+              Date publishTime);
+
+  Map<Id,Id> listIds(SessionContext context, ElementContext elementContext);
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementStageStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementStageStore.java
new file mode 100644
index 0000000000..a9236247f9
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementStageStore.java
@@ -0,0 +1,35 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.datatypes.item.Resolution;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.StageEntity;
+
+import java.util.Collection;
+import java.util.Optional;
+
+public interface ElementStageStore {
+
+  Collection<ElementEntity> listIds(SessionContext context, ElementContext elementContext);
+
+  boolean hasConflicts(SessionContext context, ElementContext elementContext);
+
+  Collection<StageEntity<ElementEntity>> listConflictedDescriptors(SessionContext context,
+                                                                   ElementContext elementContext);
+
+  Optional<StageEntity<ElementEntity>> get(SessionContext context, ElementContext elementContext,
+                                           ElementEntity element);
+
+  Optional<StageEntity<ElementEntity>> getConflicted(SessionContext context,
+                                                     ElementContext elementContext,
+                                                     ElementEntity element);
+
+  void create(SessionContext context, ElementContext elementContext,
+              StageEntity<ElementEntity> elementStage);
+
+  void delete(SessionContext context, ElementContext elementContext, ElementEntity element);
+
+  void resolveConflict(SessionContext context, ElementContext elementContext, ElementEntity element,
+                       Resolution resolution);
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementStore.java
new file mode 100644
index 0000000000..1c26a817ae
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ElementStore.java
@@ -0,0 +1,20 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+
+import java.util.Collection;
+import java.util.Optional;
+
+public interface ElementStore {
+  Optional<ElementEntity> get(SessionContext context, ElementContext elementContext, Id elementId);
+
+  Optional<ElementEntity> getDescriptor(SessionContext context, ElementContext elementContext,
+                                        Id elementId);
+
+  Collection<SynchronizationStateEntity> listSynchronizationStates(SessionContext context,
+                                                                   ElementContext elementContext);
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ErrorCode.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ErrorCode.java
new file mode 100644
index 0000000000..3d0910072c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/ErrorCode.java
@@ -0,0 +1,5 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+public class ErrorCode {
+  public static final int NO_CHANGES_TO_PUBLISH = 60000;
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/Message.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/Message.java
new file mode 100644
index 0000000000..2816974307
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/Message.java
@@ -0,0 +1,6 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+public class Message {
+  public static final String NO_CHANGES_TO_PUBLISH =
+      "Item Id %s, version Id %s: There are no changes to publish.";
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/PublishService.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/PublishService.java
new file mode 100644
index 0000000000..7b043c830f
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/PublishService.java
@@ -0,0 +1,201 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Action;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.datatypes.response.ReturnCode;
+import com.amdocs.zusammen.datatypes.response.ZusammenException;
+import com.amdocs.zusammen.sdk.collaboration.types.CollaborationMergeChange;
+import com.amdocs.zusammen.sdk.collaboration.types.CollaborationPublishResult;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+import static com.amdocs.zusammen.datatypes.response.Module.ZCSP;
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginConstants.ROOT_ELEMENTS_PARENT_ID;
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.convertToElementChange;
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.convertToVersionChange;
+import static org.openecomp.core.zusammen.plugin.collaboration.ErrorCode.NO_CHANGES_TO_PUBLISH;
+
+public class PublishService {
+  // TODO: 6/29/2017 throw ZusammenException with ReturnCode when needed.
+  private static final String PUSH_NON_EXISTING_VERSION =
+      "Item Id %s, version Id %s: Non existing version cannot be pushed.";
+
+  private VersionPublicStore versionPublicStore;
+  private VersionPrivateStore versionPrivateStore;
+  private ElementPublicStore elementPublicStore;
+  private ElementPrivateStore elementPrivateStore;
+
+  public PublishService(VersionPublicStore versionPublicStore,
+                        VersionPrivateStore versionPrivateStore,
+                        ElementPublicStore elementPublicStore,
+                        ElementPrivateStore elementPrivateStore) {
+    this.versionPublicStore = versionPublicStore;
+    this.versionPrivateStore = versionPrivateStore;
+    this.elementPublicStore = elementPublicStore;
+    this.elementPrivateStore = elementPrivateStore;
+  }
+
+  public CollaborationPublishResult publish(SessionContext context, Id itemId, Id versionId,
+                                            String message) {
+    CollaborationPublishResult result = new CollaborationPublishResult();
+    result.setChange(new CollaborationMergeChange());
+
+    Date publishTime = new Date();
+    Id revisionId = new Id(UUID.randomUUID().toString());
+    boolean versionFirstPublication = publishVersion(context, itemId, versionId, revisionId,
+        publishTime,message);
+    if (versionFirstPublication) {
+      publishAllElements(context, new ElementContext(itemId, versionId, revisionId), publishTime,
+          result);
+    } else {
+      publishDirtyElements(context, new ElementContext(itemId, versionId, revisionId), publishTime,
+          result);
+    }
+    return result;
+  }
+
+  private boolean publishVersion(SessionContext context, Id itemId, Id versionId, Id revisionId,
+                                 Date publishTime, String message) {
+    SynchronizationStateEntity privateVersionSyncState =
+        versionPrivateStore.getSynchronizationState(context, itemId, versionId)
+            .orElseThrow(() -> new IllegalArgumentException(
+                String.format(PUSH_NON_EXISTING_VERSION, itemId.toString(), versionId.toString())));
+
+    if (!privateVersionSyncState.isDirty()) {
+      throw new ZusammenException(new ReturnCode(NO_CHANGES_TO_PUBLISH, ZCSP,
+          String.format(Message.NO_CHANGES_TO_PUBLISH, itemId, versionId), null));
+    }
+
+    Optional<SynchronizationStateEntity> publicVersionSyncState =
+        versionPublicStore.getSynchronizationState(context, itemId, versionId);
+
+    // private must be synced with public (if public exists)
+    if (publicVersionSyncState.isPresent() &&
+        !privateVersionSyncState.getPublishTime()
+            .equals(publicVersionSyncState.get().getPublishTime())) {
+      // should not happen as it is validated in zusammen-core
+      throw new UnsupportedOperationException("Out of sync item version can not be publish");
+    }
+
+    boolean versionFirstPublication;
+    Map<Id, Id> versionElementIds =
+        elementPublicStore.listIds(context, new ElementContext(itemId,
+            versionId));
+    if (publicVersionSyncState.isPresent()) {
+      versionPublicStore.update(context, itemId, new VersionEntity(versionId), revisionId,
+          versionElementIds,publishTime,message);
+      versionFirstPublication = false;
+    } else {
+      VersionEntity privateVersion = versionPrivateStore.get(context, itemId, versionId)
+          .orElseThrow(() -> new IllegalArgumentException(
+              String.format(PUSH_NON_EXISTING_VERSION, itemId.toString(), versionId.toString())));
+      versionPublicStore.create(context, itemId, privateVersion, revisionId,versionElementIds,
+          publishTime,message);
+      versionFirstPublication = true;
+    }
+    versionPrivateStore.markAsPublished(context, itemId, versionId, publishTime);
+    return versionFirstPublication;
+  }
+
+  private void publishAllElements(SessionContext context, ElementContext elementContext,
+                                  Date publishTime, CollaborationPublishResult result) {
+    Collection<SynchronizationStateEntity> privateElementSyncStates =
+        elementPrivateStore.listSynchronizationStates(context, elementContext);
+
+    for (SynchronizationStateEntity privateElementSyncState : privateElementSyncStates) {
+      Optional<ElementEntity> privateElement =
+          elementPrivateStore.get(context, elementContext, privateElementSyncState.getId());
+
+      if (!privateElement.isPresent()) {
+        continue;
+      }
+      ElementEntity elementToPublish = privateElement.get();
+
+      elementPublicStore.create(context, elementContext, elementToPublish,
+          privateElementSyncState.isDirty() ? publishTime
+              : privateElementSyncState.getPublishTime());
+
+      if (privateElementSyncState.isDirty()) {
+        elementPrivateStore
+            .markAsPublished(context, elementContext, privateElementSyncState.getId(), publishTime);
+      }
+      updateResult(elementContext, elementToPublish, Action.CREATE,
+          ROOT_ELEMENTS_PARENT_ID.equals(privateElementSyncState.getId()), result);
+    }
+  }
+
+  private void publishDirtyElements(SessionContext context, ElementContext elementContext,
+                                    Date publishTime, CollaborationPublishResult result) {
+
+    Id revisionId = elementContext.getRevisionId();
+    elementContext.setRevisionId(revisionId);
+    ElementContext privateElementContext = new ElementContext(elementContext.getItemId(),
+        elementContext.getVersionId(),Id.ZERO);
+    Collection<SynchronizationStateEntity> privateElementSyncStates =
+        elementPrivateStore.listSynchronizationStates(context, elementContext);
+
+    Collection<SynchronizationStateEntity> publicElementSyncStates =
+        elementPublicStore.listSynchronizationStates(context, elementContext);
+
+    for (SynchronizationStateEntity privateElementSyncState : privateElementSyncStates) {
+      if (!privateElementSyncState.isDirty()) {
+        continue;
+      }
+
+      Optional<ElementEntity> privateElement =
+          elementPrivateStore.get(context, privateElementContext, privateElementSyncState.getId());
+
+      ElementEntity elementToPublish;
+      Action actionOnPublic;
+      if (privateElement.isPresent()) {
+        elementToPublish = privateElement.get();
+
+        if (publicElementSyncStates.contains(privateElementSyncState)) {
+
+          elementPublicStore.update(context, elementContext, elementToPublish, publishTime);
+          actionOnPublic = Action.UPDATE;
+        } else {
+          elementPublicStore.create(context, elementContext, elementToPublish, publishTime);
+          actionOnPublic = Action.CREATE;
+        }
+
+        elementPrivateStore
+            .markAsPublished(context, privateElementContext, privateElementSyncState.getId(), publishTime);
+      } else {
+        elementToPublish =
+            elementPublicStore.get(context, elementContext, privateElementSyncState.getId())
+                .orElseThrow(() -> new IllegalStateException(
+                    "Element that should be deleted from public must exist there"));
+        elementPublicStore.delete(context, elementContext, elementToPublish, publishTime);
+        actionOnPublic = Action.DELETE;
+
+        elementPrivateStore
+            .markDeletionAsPublished(context, privateElementContext, privateElementSyncState.getId(),
+                publishTime);
+      }
+
+      updateResult(elementContext, elementToPublish, actionOnPublic,
+          ROOT_ELEMENTS_PARENT_ID.equals(privateElementSyncState.getId()), result);
+    }
+  }
+
+  private void updateResult(ElementContext elementContext, ElementEntity element,
+                            Action action, boolean versionDataElement,
+                            CollaborationPublishResult result) {
+    if (versionDataElement) {
+      result.getChange().setChangedVersion(convertToVersionChange(elementContext, element, action));
+    } else {
+      result.getChange().getChangedElements()
+          .add(convertToElementChange(elementContext, element, action));
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/RevertService.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/RevertService.java
new file mode 100644
index 0000000000..0d2ea2c0d8
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/RevertService.java
@@ -0,0 +1,161 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class RevertService {
+
+  private ElementPublicStore elementPublicStore;
+  private ElementPrivateStore elementPrivateStore;
+
+  public RevertService(ElementPublicStore elementPublicStore,
+                       ElementPrivateStore elementPrivateStore) {
+    this.elementPublicStore = elementPublicStore;
+    this.elementPrivateStore = elementPrivateStore;
+  }
+
+  public void revert(SessionContext context, Id itemId, Id versionId, Id revisionId) {
+    ElementContext targetContext = new ElementContext(itemId, versionId);
+    ElementContext sourceContext = new ElementContext(itemId, versionId, revisionId);
+    copyElementsFromPublic(context, sourceContext, targetContext);
+  }
+
+  private void copyElementsFromPublic(SessionContext context, ElementContext sourceContext,
+                                      ElementContext targetContext) {
+    Collection<RevertElementAction> revertElementActions =
+        evaluateRevertElementActions(context, sourceContext, targetContext);
+
+    revertElementActions.forEach(revertElementAction -> revertElementAction.run(context));
+  }
+
+  private Collection<RevertElementAction> evaluateRevertElementActions(SessionContext context,
+                                                                       ElementContext sourceContext,
+                                                                       ElementContext targetContext) {
+
+    Map<Id, Id> sourceElements = elementPublicStore.listIds(context, sourceContext);
+    Map<Id, Id> targetPublicElements = elementPublicStore.listIds(context, targetContext);
+    Collection<SynchronizationStateEntity> synchronizationStateEntities =
+        elementPrivateStore.listSynchronizationStates(context, targetContext);
+
+    Map<Id, Id> targetElements =
+        evaluateTargetElements(targetPublicElements, synchronizationStateEntities);
+
+
+    Collection<RevertElementAction> revertElementActions = new ArrayList<>();
+
+    sourceElements.entrySet().forEach(entry -> {
+      Id sourceElementId = entry.getKey();
+      Id sourceElementRevisionId = entry.getValue();
+
+      if (!targetElements.containsKey(sourceElementId)) {
+        revertElementActions
+            .add(new RevertElementAction(sourceContext, sourceElementId, commands[CREATE]));
+      } else if (!targetElements.get(sourceElementId).equals(sourceElementRevisionId)) {
+        revertElementActions
+            .add(new RevertElementAction(sourceContext, sourceElementId, commands[UPDATE]));
+      }
+    });
+
+    targetElements.entrySet().forEach(entry -> {
+      Id targetElementId = entry.getKey();
+      if (!sourceElements.containsKey(targetElementId)) {
+        revertElementActions
+            .add(new RevertElementAction(targetContext, targetElementId, commands[DELETE]));
+      }
+    });
+
+    return revertElementActions;
+  }
+
+  private Map<Id, Id> evaluateTargetElements(Map<Id, Id> targetPublicElements,
+                                             Collection<SynchronizationStateEntity> syncStates) {
+    Map<Id, Id> targetElements = new HashMap<>(targetPublicElements);
+    syncStates.stream()
+        .filter(SynchronizationStateEntity::isDirty)
+        .forEach(syncState -> targetElements.put(syncState.getId(), Id.ZERO));
+    return targetElements;
+  }
+
+  private static class RevertElementAction {
+    private ElementContext elementContext;
+    private Id elementId;
+    private ActionCommand command;
+
+    private RevertElementAction(ElementContext elementContext, Id elementId,
+                                ActionCommand command) {
+      this.elementContext = elementContext;
+      this.elementId = elementId;
+      this.command = command;
+    }
+
+    public ElementContext getElementContext() {
+      return elementContext;
+    }
+
+    public Id getElementId() {
+      return elementId;
+    }
+
+    public void run(SessionContext context) {
+      command.run(context, elementContext, elementId);
+    }
+  }
+
+  private interface ActionCommand {
+    void run(SessionContext context, ElementContext elementContext, Id elementId);
+  }
+
+  private static int CREATE = 0;
+  private static int UPDATE = 1;
+  private static int DELETE = 2;
+
+  private ActionCommand[] commands = {new ActionCommand() {
+    @Override
+    public void run(SessionContext context, ElementContext elementContext, Id elementId) {
+      //create
+      Optional<ElementEntity> element = elementPublicStore.get(context, elementContext, elementId);
+      if (!element.isPresent()) {
+        throw getMissingElementException(elementContext, elementId);
+      }
+      elementPrivateStore.create(context, elementContext, element.get());
+    }
+  }, new ActionCommand() {
+    @Override
+    public void run(SessionContext context, ElementContext elementContext, Id elementId) {
+      //update
+      Optional<ElementEntity> element = elementPublicStore.get(context, elementContext, elementId);
+      if (!element.isPresent()) {
+        throw getMissingElementException(elementContext, elementId);
+      }
+      elementPrivateStore.update(context, elementContext, element.get());
+    }
+  }, new ActionCommand() {
+    @Override
+    public void run(SessionContext context, ElementContext elementContext, Id elementId) {
+      //delete
+      Optional<ElementEntity> element = elementPrivateStore.get(context, elementContext, elementId);
+      if (!element.isPresent()) {
+        return; // deleted by parent when hierarchy was deleted
+      }
+      elementPrivateStore.delete(context, elementContext, element.get());
+    }
+  }};
+
+  private RuntimeException getMissingElementException(ElementContext elementContext,
+                                                      Id elementId) {
+    return new IllegalStateException(
+        String.format("Item Id %s, version Id %s, revision Id %s: Missing element with Id %s",
+            elementContext.getItemId().getValue(), elementContext.getVersionId().getValue(),
+            elementContext.getRevisionId().getValue(), elementId.getValue())
+    );
+  }
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/SyncService.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/SyncService.java
new file mode 100644
index 0000000000..04a7e9ffb1
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/SyncService.java
@@ -0,0 +1,384 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Action;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.sdk.collaboration.types.CollaborationMergeChange;
+import com.amdocs.zusammen.sdk.collaboration.types.CollaborationMergeConflict;
+import com.amdocs.zusammen.sdk.collaboration.types.CollaborationMergeResult;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.StageEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginConstants.ROOT_ELEMENTS_PARENT_ID;
+
+public class SyncService {
+  private static final String PULL_NON_EXISTING_VERSION =
+      "Item Id %s, version Id %s: Non existing version cannot be synced.";
+  private static final String PUBLIC_SYNC_STATE_EXISTS_WITHOUT_ELEMENT =
+      "Item Id %s, version Id %s: Sync state of element with Id %s " +
+          "exists in public space while the element does not";
+  private static final String PRIVATE_UNPUBLISHED_SYNC_STATE_EXISTS_WITHOUT_ELEMENT =
+      "Item Id %s, version Id %s: Sync state of unpublished element with Id %s " +
+          "exists in private space while the element does not";
+
+  private VersionPublicStore versionPublicStore;
+  private VersionPrivateStore versionPrivateStore;
+  private VersionStageStore versionStageStore;
+  private ElementPublicStore elementPublicStore;
+  private ElementPrivateStore elementPrivateStore;
+  private ElementStageStore elementStageStore;
+
+  public SyncService(VersionPublicStore versionPublicStore,
+                     VersionPrivateStore versionPrivateStore,
+                     VersionStageStore versionStageStore,
+                     ElementPublicStore elementPublicStore,
+                     ElementPrivateStore elementPrivateStore,
+                     ElementStageStore elementStageStore) {
+    this.versionPublicStore = versionPublicStore;
+    this.versionPrivateStore = versionPrivateStore;
+    this.versionStageStore = versionStageStore;
+    this.elementPublicStore = elementPublicStore;
+    this.elementPrivateStore = elementPrivateStore;
+    this.elementStageStore = elementStageStore;
+  }
+
+  public CollaborationMergeResult sync(SessionContext context, Id itemId, Id versionId,
+                                       boolean force) {
+    SynchronizationStateEntity publicVersionSyncState =
+        versionPublicStore.getSynchronizationState(context, itemId, versionId)
+            .orElseThrow(() -> new IllegalStateException(
+                String.format(PULL_NON_EXISTING_VERSION, itemId.toString(), versionId.toString())));
+
+    Date publishTime = publicVersionSyncState.getPublishTime();
+
+    Optional<SynchronizationStateEntity> privateVersionSyncState =
+        versionPrivateStore.getSynchronizationState(context, itemId, versionId);
+
+    if (force || !privateVersionSyncState.isPresent() ||
+        !publishTime.equals(privateVersionSyncState.get().getPublishTime())) {
+      ElementContext elementContext =
+          new ElementContext(itemId, versionId, publicVersionSyncState.getRevisionId());
+
+      Collection<SynchronizationStateEntity> publicSyncStates =
+          elementPublicStore.listSynchronizationStates(context, elementContext);
+      Collection<SynchronizationStateEntity> privateSyncStates =
+          elementPrivateStore.listSynchronizationStates(context, elementContext);
+      Map<Id, SynchronizationStateEntity> publicSyncStateById = toMapById(publicSyncStates);
+
+      Set<Id> syncedElements = new HashSet<>();
+      if (force) {
+        List<SynchronizationStateEntity> dirtyPrivateSyncStates = privateSyncStates.stream()
+            .filter(SynchronizationStateEntity::isDirty)
+            .collect(Collectors.toList());
+
+        forceSyncDirtyElements(context, elementContext, dirtyPrivateSyncStates, publicSyncStateById,
+            syncedElements);
+      }
+
+      if (!privateVersionSyncState.isPresent() ||
+          !publishTime.equals(privateVersionSyncState.get().getPublishTime())) {
+        syncVersion(context, itemId, versionId, publishTime, privateVersionSyncState.isPresent());
+        syncElements(context, elementContext,
+            privateVersionSyncState.map(SynchronizationStateEntity::getPublishTime).orElse(null),
+            publicSyncStates, privateSyncStates, publicSyncStateById, syncedElements);
+      }
+    }
+
+    return createResult();
+  }
+
+  private CollaborationMergeResult createResult() {
+    CollaborationMergeResult result = new CollaborationMergeResult();
+    result.setChange(new CollaborationMergeChange());
+    result.setConflict(new CollaborationMergeConflict());
+    return result;
+  }
+
+  private void syncVersion(SessionContext context, Id itemId, Id versionId, Date publishTime,
+                           boolean versionExistOnPrivate) {
+    if (versionExistOnPrivate) {
+      stageVersion(context, itemId, new VersionEntity(versionId), Action.UPDATE, publishTime);
+    } else {
+      stageVersion(context, itemId, versionPublicStore.get(context, itemId, versionId)
+              .orElseThrow(() -> new IllegalArgumentException(String
+                  .format(PULL_NON_EXISTING_VERSION, itemId.toString(), versionId.toString()))),
+          Action.CREATE, publishTime);
+    }
+  }
+
+  private void syncElements(SessionContext context, ElementContext elementContext,
+                            Date previousSyncedPublishTime,
+                            Collection<SynchronizationStateEntity> publicSyncStates,
+                            Collection<SynchronizationStateEntity> privateSyncStates,
+                            Map<Id, SynchronizationStateEntity> publicSyncStateById,
+                            Set<Id> syncedElements) {
+    Map<Id, SynchronizationStateEntity> privateSyncStateById = toMapById(privateSyncStates);
+
+    Collection<SynchronizationStateEntity> updatedPublicSyncStates =
+        previousSyncedPublishTime == null
+            ? publicSyncStates
+            : publicSyncStates.stream()
+                .filter(syncState -> syncState.getPublishTime().after(previousSyncedPublishTime))
+                .collect(Collectors.toList());
+
+    syncPublicUpdatedElements(context, elementContext, updatedPublicSyncStates,
+        publicSyncStateById, privateSyncStateById, syncedElements);
+
+    List<SynchronizationStateEntity> onlyOnPrivatePublishedSyncStates =
+        privateSyncStates.stream()
+            .filter(syncState -> !publicSyncStateById.containsKey(syncState.getId()) &&
+                syncState.getPublishTime() != null)
+            .collect(Collectors.toList());
+
+    syncPublicDeletedElements(context, elementContext, onlyOnPrivatePublishedSyncStates,
+        publicSyncStateById, privateSyncStateById, syncedElements);
+  }
+
+  private void syncPublicUpdatedElements(SessionContext context, ElementContext elementContext,
+                                         Collection<SynchronizationStateEntity> updatedPublicSyncStates,
+                                         Map<Id, SynchronizationStateEntity> publicSyncStateById,
+                                         Map<Id, SynchronizationStateEntity> privateSyncStateById,
+                                         Set<Id> syncedElements) {
+    for (SynchronizationStateEntity publicSyncState : updatedPublicSyncStates) {
+      if (syncedElements.contains(publicSyncState.getId())) {
+        continue;
+      }
+
+      ElementEntity publicElement =
+          elementPublicStore.get(context, elementContext, publicSyncState.getId()).orElseThrow(
+              () -> new IllegalStateException(String
+                  .format(PUBLIC_SYNC_STATE_EXISTS_WITHOUT_ELEMENT,
+                      elementContext.getItemId().getValue(),
+                      elementContext.getVersionId().getValue(),
+                      publicSyncState.getId().getValue())));
+
+      SynchronizationStateEntity privateSyncState =
+          privateSyncStateById.get(publicSyncState.getId());
+
+      if (privateSyncState != null) {
+        if (!privateSyncState.isDirty()) {
+          // not changed on private
+          stageElement(context, elementContext, publicElement,
+              publicSyncState.getPublishTime(),
+              Action.UPDATE, false, null);
+          syncedElements.add(publicSyncState.getId());
+        } else {
+          Optional<ElementEntity> privateElement =
+              elementPrivateStore.get(context, elementContext, publicSyncState.getId());
+
+          if (privateElement.isPresent()) {
+            // updated on private - conflict if it has different hash
+            stageElement(context, elementContext, publicElement,
+                publicSyncState.getPublishTime(), Action.UPDATE,
+                !publicElement.getElementHash().equals(privateElement.get().getElementHash()),
+                null);
+
+            syncedElements.add(publicSyncState.getId());
+          } else {
+            // deleted on private - conflict tree
+            Set<Id> changeTreeElementIds =
+                stagePublicElementTree(context, elementContext, publicElement, publicSyncStateById,
+                    (treeElementIds) -> true);
+            syncedElements.addAll(changeTreeElementIds);
+          }
+        }
+      } else {
+        // not existing on private - new creation on public
+        Set<Id> changeTreeElementIds =
+            stagePublicElementTree(context, elementContext, publicElement, publicSyncStateById,
+                (treeElementIds) -> containsDirty(treeElementIds, privateSyncStateById));
+        syncedElements.addAll(changeTreeElementIds);
+      }
+    }
+  }
+
+  private void syncPublicDeletedElements(
+      SessionContext context, ElementContext elementContext,
+      Collection<SynchronizationStateEntity> onlyOnPrivatePublishedSyncStates,
+      Map<Id, SynchronizationStateEntity> publicSyncStateById,
+      Map<Id, SynchronizationStateEntity> privateSyncStateById,
+      Set<Id> syncedElements) {
+    for (SynchronizationStateEntity privateSyncState : onlyOnPrivatePublishedSyncStates) {
+      if (syncedElements.contains(privateSyncState.getId())) {
+        continue;
+      }
+
+      Optional<ElementEntity> privateElement =
+          elementPrivateStore.get(context, elementContext, privateSyncState.getId());
+
+      if (!privateElement.isPresent()) {
+        // deleted on private as well
+        stageElement(context, elementContext, new ElementEntity(privateSyncState.getId()),
+            null, Action.DELETE, false, null);
+        syncedElements.add(privateSyncState.getId());
+      } else {
+        Set<Id> changeTreeElementIds =
+            stageElementTree(context, elementContext, privateElement.get(),
+                elementPrivateStore, publicSyncStateById::containsKey,
+                (treeElementIds) -> containsDirty(treeElementIds, privateSyncStateById),
+                (elementId) -> null, Action.DELETE);
+        syncedElements.addAll(changeTreeElementIds);
+      }
+    }
+  }
+
+  private void forceSyncDirtyElements(SessionContext context, ElementContext elementContext,
+                                      List<SynchronizationStateEntity> dirtyPrivateSyncStates,
+                                      Map<Id, SynchronizationStateEntity> publicSyncStateById,
+                                      Set<Id> syncedElements) {
+    for (SynchronizationStateEntity privateSyncState : dirtyPrivateSyncStates) {
+      Optional<ElementEntity> privateElement =
+          elementPrivateStore.get(context, elementContext, privateSyncState.getId());
+      if (privateSyncState.getPublishTime() == null) {
+        stageElement(context, elementContext,
+            privateElement.orElseThrow(() -> new IllegalStateException(
+                String.format(PRIVATE_UNPUBLISHED_SYNC_STATE_EXISTS_WITHOUT_ELEMENT,
+                    elementContext.getItemId().getValue(),
+                    elementContext.getVersionId().getValue(),
+                    privateSyncState.getId().getValue()))),
+            null, Action.DELETE, false, null);
+      } else {
+        SynchronizationStateEntity publicSyncState =
+            publicSyncStateById.get(privateSyncState.getId());
+        if (publicSyncState != null) {
+          ElementEntity publicElement =
+              elementPublicStore.get(context, elementContext, privateSyncState.getId()).orElseThrow(
+                  () -> new IllegalStateException(String
+                      .format(PUBLIC_SYNC_STATE_EXISTS_WITHOUT_ELEMENT,
+                          elementContext.getItemId().getValue(),
+                          elementContext.getVersionId().getValue(),
+                          privateSyncState.getId().getValue())));
+
+          stageElement(context, elementContext, publicElement, publicSyncState.getPublishTime(),
+              privateElement.isPresent() ? Action.UPDATE : Action.CREATE, false, null);
+        } else {
+          stageElement(context, elementContext, privateElement.isPresent()
+                  ? privateElement.get()
+                  : new ElementEntity(privateSyncState.getId()),
+              null, Action.DELETE, false, null);
+        }
+      }
+      syncedElements.add(privateSyncState.getId());
+    }
+  }
+
+  private Set<Id> stagePublicElementTree(SessionContext context,
+                                         ElementContext elementContext,
+                                         ElementEntity publicElement,
+                                         Map<Id, SynchronizationStateEntity> publicSyncStateById,
+                                         Predicate<Set<Id>> isElementTreeConflicted) {
+
+
+    return stageElementTree(context, elementContext, publicElement,
+        elementPublicStore,
+        (elementId) -> elementPrivateStore.getDescriptor(context, elementContext, elementId)
+            .isPresent(),
+        isElementTreeConflicted,
+        (elementId) -> publicSyncStateById.get(elementId).getPublishTime(),
+        Action.CREATE);
+  }
+
+  private Set<Id> stageElementTree(SessionContext context, ElementContext elementContext,
+                                   ElementEntity element,
+                                   ElementStore elementStore,
+                                   Predicate<Id> isElementExist,
+                                   Predicate<Set<Id>> isElementTreeConflicted,
+                                   Function<Id, Date> stagePublishTimeGetter,
+                                   Action stageAction) {
+    ElementEntity elementTreeRoot = findRootElementOfChange(context, elementContext,
+        elementStore, isElementExist, element);
+
+    Set<Id> elementTreeIds = new HashSet<>();
+    elementTreeIds.add(elementTreeRoot.getId());
+
+    Set<Id> subElementIds = stageElementSubs(context, elementContext, elementStore, elementTreeRoot,
+        stagePublishTimeGetter, stageAction);
+    elementTreeIds.addAll(subElementIds);
+
+    boolean conflicted = isElementTreeConflicted.test(elementTreeIds);
+    stageElement(context, elementContext, elementTreeRoot,
+        stagePublishTimeGetter.apply(elementTreeRoot.getId()), stageAction, conflicted,
+        conflicted ? subElementIds : null);
+    return elementTreeIds;
+  }
+
+  private ElementEntity findRootElementOfChange(SessionContext context,
+                                                ElementContext elementContext,
+                                                ElementStore elementStore,
+                                                Predicate<Id> isElementExistOnOppositeStore,
+                                                ElementEntity element) {
+    return element.getId().equals(ROOT_ELEMENTS_PARENT_ID) ||
+        isElementExistOnOppositeStore.test(element.getParentId())
+        ? element
+        : findRootElementOfChange(context, elementContext, elementStore,
+            isElementExistOnOppositeStore,
+            elementStore.get(context, elementContext, element.getParentId())
+                .orElseThrow(() -> new IllegalStateException(
+                    String.format("Element %s exists while its parent element %s does not",
+                        element.getId(), element.getParentId()))));
+  }
+
+  private boolean containsDirty(Set<Id> elementIds,
+                                Map<Id, SynchronizationStateEntity> syncStateById) {
+    return elementIds.stream().anyMatch(elementId -> {
+      SynchronizationStateEntity privateSyncState = syncStateById.get(elementId);
+      return privateSyncState != null && privateSyncState.isDirty();
+    });
+  }
+
+  private Set<Id> stageElementSubs(SessionContext context, ElementContext elementContext,
+                                   ElementStore elementStore, ElementEntity parentElement,
+                                   Function<Id, Date> stagePublishTimeGetter, Action stageAction) {
+    Set<Id> elementTreeIds = new HashSet<>();
+    for (Id elementId : parentElement.getSubElementIds()) {
+      ElementEntity element = elementStore.get(context, elementContext, elementId).get();
+
+      stageElement(context, elementContext, element, stagePublishTimeGetter.apply(elementId),
+          stageAction, false, null);
+
+      elementTreeIds.add(elementId);
+      elementTreeIds.addAll(
+          stageElementSubs(context, elementContext, elementStore, element, stagePublishTimeGetter,
+              stageAction));
+    }
+    return elementTreeIds;
+  }
+
+  private void stageElement(SessionContext context, ElementContext elementContext,
+                            ElementEntity element, Date publishTime, Action action,
+                            boolean conflicted, Set<Id> conflictDependents) {
+    StageEntity<ElementEntity> elementStage =
+        new StageEntity<>(element, publishTime, action, conflicted);
+    if (conflictDependents != null) {
+      elementStage.setConflictDependents(
+          conflictDependents.stream().map(ElementEntity::new).collect(Collectors.toSet()));
+    }
+    elementStageStore.create(context, elementContext, elementStage);
+  }
+
+  private void stageVersion(SessionContext context, Id itemId, VersionEntity stageVersion,
+                            Action stageAction, Date publishTime) {
+    versionStageStore
+        .create(context, itemId, new StageEntity<>(stageVersion, publishTime, stageAction, false));
+  }
+
+  private Map<Id, SynchronizationStateEntity> toMapById(
+      Collection<SynchronizationStateEntity> syncStates) {
+    return syncStates.stream()
+        .collect(Collectors.toMap(SynchronizationStateEntity::getId, Function.identity()));
+  }
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionCollaborationStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionCollaborationStore.java
deleted file mode 100644
index db3066c313..0000000000
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionCollaborationStore.java
+++ /dev/null
@@ -1,110 +0,0 @@
-package org.openecomp.core.zusammen.plugin.collaboration;
-
-import com.amdocs.zusammen.datatypes.Id;
-import com.amdocs.zusammen.datatypes.SessionContext;
-import com.amdocs.zusammen.datatypes.Space;
-import com.amdocs.zusammen.datatypes.item.Action;
-import com.amdocs.zusammen.datatypes.itemversion.Tag;
-import com.amdocs.zusammen.plugin.statestore.cassandra.dao.types.ElementEntityContext;
-import com.amdocs.zusammen.sdk.collaboration.types.CollaborationElementChange;
-import com.amdocs.zusammen.sdk.collaboration.types.CollaborationMergeChange;
-import org.openecomp.core.zusammen.plugin.ZusammenPluginUtil;
-import org.openecomp.core.zusammen.plugin.dao.ElementRepository;
-import org.openecomp.core.zusammen.plugin.dao.ElementRepositoryFactory;
-import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static org.openecomp.core.zusammen.plugin.ZusammenPluginConstants.ROOT_ELEMENTS_PARENT_ID;
-import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getSpaceName;
-
-public class VersionCollaborationStore {
-
-  public void tagItemVersion(SessionContext context, Id itemId, Id versionId, Id changeId,
-                             Tag tag) {
-    if (changeId != null) {
-      throw new UnsupportedOperationException(
-          "In this plugin implementation tag is supported only on versionId");
-    }
-    String space = getSpaceName(context, Space.PRIVATE);
-    ElementEntityContext targetContext = new ElementEntityContext(space, itemId, versionId);
-    targetContext.setChangeRef(tag.getName());
-    copyElements(context, new ElementEntityContext(space, itemId, versionId), targetContext,
-        getElementRepository(context));
-  }
-
-  public CollaborationMergeChange resetItemVersionHistory(SessionContext context, Id itemId,
-                                                          Id versionId, String changeRef) {
-    ElementRepository elementRepository = getElementRepository(context);
-
-    String spaceName = getSpaceName(context, Space.PRIVATE);
-    ElementEntityContext versionContext = new ElementEntityContext(spaceName, itemId, versionId);
-
-    Collection<ElementEntity> deletedElements =
-        deleteElements(context, versionContext, elementRepository);
-
-    ElementEntityContext changeRefContext = new ElementEntityContext(spaceName, itemId, versionId);
-    changeRefContext.setChangeRef(changeRef);
-
-    Collection<ElementEntity> createdElements =
-        copyElements(context, changeRefContext, versionContext, elementRepository);
-
-    // TODO: 4/19/2017 version change...
-    return createCollaborationMergeChange(versionContext, deletedElements, createdElements);
-  }
-
-  private Collection<ElementEntity> deleteElements(SessionContext context,
-                                                   ElementEntityContext elementContext,
-                                                   ElementRepository elementRepository) {
-    Collection<ElementEntity> elements = elementRepository.list(context, elementContext);
-    elements.forEach(element -> elementRepository
-        .delete(context, elementContext, new ElementEntity(element.getId())));
-    elementRepository.delete(context, elementContext, new ElementEntity(ROOT_ELEMENTS_PARENT_ID));
-    return elements;
-  }
-
-  private Collection<ElementEntity> copyElements(SessionContext context,
-                                                 ElementEntityContext sourceElementContext,
-                                                 ElementEntityContext targetElementContext,
-                                                 ElementRepository elementRepository) {
-    Collection<ElementEntity> elements = elementRepository.list(context, sourceElementContext);
-    elements.forEach(elementEntity ->
-        elementRepository.create(context, targetElementContext, elementEntity));
-    return elements;
-  }
-
-  private CollaborationMergeChange createCollaborationMergeChange(
-      ElementEntityContext versionContext,
-      Collection<ElementEntity> deletedElements,
-      Collection<ElementEntity> createdElements) {
-    CollaborationMergeChange mergeChange = new CollaborationMergeChange();
-    mergeChange.getChangedElements().addAll(
-        convertToCollaborationElementChanges(versionContext, deletedElements, Action.DELETE));
-    mergeChange.getChangedElements().addAll(
-        convertToCollaborationElementChanges(versionContext, createdElements, Action.CREATE));
-    return mergeChange;
-  }
-
-  private List<CollaborationElementChange> convertToCollaborationElementChanges(
-      ElementEntityContext elementContext, Collection<ElementEntity> changedElements,
-      Action action) {
-    return changedElements.stream()
-        .map(element -> convertToCollaborationElementChange(element, elementContext, action))
-        .collect(Collectors.toList());
-  }
-
-  private CollaborationElementChange convertToCollaborationElementChange(
-      ElementEntity elementEntity, ElementEntityContext elementContext, Action action) {
-    CollaborationElementChange elementChange = new CollaborationElementChange();
-    elementChange
-        .setElement(ZusammenPluginUtil.getCollaborationElement(elementContext, elementEntity));
-    elementChange.setAction(action);
-    return elementChange;
-  }
-
-  protected ElementRepository getElementRepository(SessionContext context) {
-    return ElementRepositoryFactory.getInstance().createInterface(context);
-  }
-}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionPrivateStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionPrivateStore.java
new file mode 100644
index 0000000000..a024327548
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionPrivateStore.java
@@ -0,0 +1,38 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Date;
+import java.util.Optional;
+
+public interface VersionPrivateStore {
+  Optional<VersionEntity> get(SessionContext context, Id itemId, Id versionId);
+
+  Optional<SynchronizationStateEntity> getSynchronizationState(SessionContext context, Id itemId,
+                                                               Id versionId);
+
+  void create(SessionContext context, Id itemId, VersionEntity version);
+
+  void update(SessionContext context, Id itemId, VersionEntity version);
+
+  void update(SessionContext context, Id itemId, VersionEntity version, Date publishTime,
+              boolean dirty);
+
+  void delete(SessionContext context, Id itemId, VersionEntity version);
+
+  void markAsPublished(SessionContext context, Id itemId, Id versionId, Date publishTime);
+
+  void commitStagedCreate(SessionContext context, Id itemId, VersionEntity version,
+                          Date publishTime);
+
+  void commitStagedUpdate(SessionContext context, Id itemId, VersionEntity version,
+                          Date publishTime);
+
+  void commitStagedIgnore(SessionContext context, Id itemId, VersionEntity version,
+                          Date publishTime);
+
+
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionPublicStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionPublicStore.java
new file mode 100644
index 0000000000..c86db0ec43
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionPublicStore.java
@@ -0,0 +1,29 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Date;
+import java.util.Map;
+import java.util.Optional;
+
+public interface VersionPublicStore {
+
+  Optional<VersionEntity> get(SessionContext context, Id itemId, Id versionId);
+
+  Optional<SynchronizationStateEntity> getSynchronizationState(SessionContext context,
+                                                               Id itemId, Id versionId);
+
+  void create(SessionContext context, Id itemId, VersionEntity version, Id revisionId,
+              Map<Id, Id> versionElementIds, Date publishTime, String message);
+
+  void update(SessionContext context, Id itemId, VersionEntity version, Id revisionId,
+              Map<Id, Id> versionElementIds, Date publishTime, String message);
+
+  boolean checkHealth(SessionContext context);
+
+  ItemVersionRevisions listItemVersionRevisions(SessionContext context, Id itemId, Id versionId);
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionStageStore.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionStageStore.java
new file mode 100644
index 0000000000..5058a262cc
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/VersionStageStore.java
@@ -0,0 +1,18 @@
+package org.openecomp.core.zusammen.plugin.collaboration;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import org.openecomp.core.zusammen.plugin.dao.types.StageEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Optional;
+
+public interface VersionStageStore {
+
+  Optional<StageEntity<VersionEntity>> get(SessionContext context, Id itemId,
+                                           VersionEntity versionEntity);
+
+  void create(SessionContext context, Id itemId, StageEntity<VersionEntity> versionStage);
+
+  void delete(SessionContext context, Id itemId, VersionEntity version);
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementPrivateStoreImpl.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementPrivateStoreImpl.java
new file mode 100644
index 0000000000..9f54ee3ae2
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementPrivateStoreImpl.java
@@ -0,0 +1,269 @@
+package org.openecomp.core.zusammen.plugin.collaboration.impl;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.plugin.statestore.cassandra.dao.types.ElementEntityContext;
+import org.openecomp.core.zusammen.plugin.ZusammenPluginConstants;
+import org.openecomp.core.zusammen.plugin.collaboration.ElementPrivateStore;
+import org.openecomp.core.zusammen.plugin.dao.ElementRepository;
+import org.openecomp.core.zusammen.plugin.dao.ElementRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.ElementSynchronizationStateRepository;
+import org.openecomp.core.zusammen.plugin.dao.ElementSynchronizationStateRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateElementContext;
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateSpaceName;
+
+public class ElementPrivateStoreImpl implements ElementPrivateStore {
+  private static final Id REVISION_ID = Id.ZERO; // the private revision id is Id.ZERO 0000000...
+
+  @Override
+  public Map<Id, Id> listIds(SessionContext context, ElementContext elementContext) {
+    return getElementRepository(context)
+        .listIds(context, new ElementEntityContext(getPrivateSpaceName(context), elementContext));
+  }
+
+  @Override
+  public Collection<ElementEntity> listSubs(SessionContext context, ElementContext elementContext,
+                                            Id elementId) {
+    if (elementId == null) {
+      elementId = ZusammenPluginConstants.ROOT_ELEMENTS_PARENT_ID;
+    }
+
+    ElementRepository elementRepository = getElementRepository(context);
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateContext.setRevisionId(REVISION_ID);
+    return elementRepository.get(context, privateContext, new ElementEntity(elementId))
+        .map(ElementEntity::getSubElementIds).orElse(new HashSet<>()).stream()
+        .map(subElementId -> elementRepository
+            .get(context, privateContext, new ElementEntity(subElementId)).get())
+        .filter(Objects::nonNull)
+        .collect(Collectors.toList());
+  }
+
+  @Override
+  public Optional<ElementEntity> get(SessionContext context, ElementContext elementContext,
+                                     Id elementId) {
+    ElementEntityContext privateElementContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateElementContext.setRevisionId(REVISION_ID);
+    return getElementRepository(context)
+        .get(context, privateElementContext,
+            new ElementEntity(elementId));
+  }
+
+  @Override
+  public Optional<ElementEntity> getDescriptor(SessionContext context,
+                                               ElementContext elementContext, Id elementId) {
+    return getElementRepository(context)
+        .getDescriptor(context,
+            new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext
+                (elementContext)),
+            new ElementEntity(elementId));
+  }
+
+  @Override
+  public Collection<SynchronizationStateEntity> listSynchronizationStates(SessionContext context,
+                                                                          ElementContext elementContext) {
+    ElementEntityContext privateElementContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    return getElementSyncStateRepository(context)
+        .list(context, privateElementContext);
+  }
+
+  @Override
+  public Optional<SynchronizationStateEntity> getSynchronizationState(SessionContext context,
+                                                                      ElementContext elementContext,
+                                                                      Id elementId) {
+
+    ElementEntityContext privateElementContext =
+        new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext
+            (elementContext));
+    return getElementSyncStateRepository(context)
+        .get(context, privateElementContext,
+            new SynchronizationStateEntity(elementId, REVISION_ID));
+  }
+
+  @Override
+  public void create(SessionContext context, ElementContext elementContext, ElementEntity element) {
+    create(context, elementContext, element, true, null);
+  }
+
+  @Override
+  public boolean update(SessionContext context, ElementContext elementContext,
+                        ElementEntity element) {
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateContext.setRevisionId(REVISION_ID);
+
+    if (!isElementChanged(context, privateContext, element)) {
+      return false;
+    }
+
+    getElementRepository(context).update(context, privateContext, element);
+    getElementSyncStateRepository(context).markAsDirty(context, privateContext,
+        new SynchronizationStateEntity(element.getId(), REVISION_ID));
+    return true;
+  }
+
+  @Override
+  public void delete(SessionContext context, ElementContext elementContext, ElementEntity element) {
+
+    ElementEntityContext privateElementContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateElementContext.setRevisionId(REVISION_ID);
+    deleteElementHierarchy(context, getElementRepository(context),
+        getElementSyncStateRepository(context),
+        privateElementContext, element);
+  }
+
+  @Override
+  public void markAsPublished(SessionContext context, ElementContext elementContext, Id elementId,
+                              Date publishTime) {
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateContext.setRevisionId(REVISION_ID);
+    getElementSyncStateRepository(context).update(context,
+        privateContext,
+        new SynchronizationStateEntity(elementId, REVISION_ID, publishTime, false));
+  }
+
+  @Override
+  public void markDeletionAsPublished(SessionContext context, ElementContext elementContext,
+                                      Id elementId, Date publishTime) {
+
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateContext.setRevisionId(REVISION_ID);
+    getElementSyncStateRepository(context).delete(context,
+        privateContext,
+        new SynchronizationStateEntity(elementId, REVISION_ID));
+  }
+
+  @Override
+  public void commitStagedCreate(SessionContext context, ElementContext elementContext,
+                                 ElementEntity element, Date publishTime) {
+    create(context, elementContext, element, false, publishTime);
+  }
+
+  @Override
+  public void commitStagedUpdate(SessionContext context, ElementContext elementContext,
+                                 ElementEntity element, Date publishTime) {
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateContext.setRevisionId(REVISION_ID);
+
+    getElementRepository(context).update(context, privateContext, element);
+    // Currently Resolution='Other' is not supported so this is invoked after conflict was
+    // resolved with Resolution='Theirs' so dirty flag should be turned off.
+    // (if there was no conflict it's off anyway)
+    getElementSyncStateRepository(context).update(context, privateContext,
+        new SynchronizationStateEntity(element.getId(), REVISION_ID, publishTime, false));
+  }
+
+  @Override
+  public void commitStagedDelete(SessionContext context, ElementContext elementContext,
+                                 ElementEntity element) {
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateContext.setRevisionId(REVISION_ID);
+    getElementRepository(context).delete(context, privateContext, element);
+    getElementSyncStateRepository(context)
+        .delete(context, privateContext,
+            new SynchronizationStateEntity(element.getId(), REVISION_ID));
+  }
+
+  @Override
+  public void commitStagedIgnore(SessionContext context, ElementContext elementContext,
+                                 ElementEntity element, Date publishTime) {
+    // publish time - updated to mark that this element was already synced with this publish time
+    // (even though the local data was preferred) and to prevent this conflict again.
+    // dirty - turned on because the local data which is different than the public one was
+    // preferred. It will enable future publication of this data.
+    getElementSyncStateRepository(context).update(context,
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext),
+        new SynchronizationStateEntity(element.getId(), REVISION_ID, publishTime, true));
+  }
+
+  private void create(SessionContext context, ElementContext elementContext,
+                      ElementEntity element, boolean dirty, Date publishTime) {
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), elementContext);
+    privateContext.setRevisionId(REVISION_ID);
+    getElementRepository(context).create(context, privateContext, element);
+    getElementSyncStateRepository(context).create(context, privateContext,
+        new SynchronizationStateEntity(element.getId(), REVISION_ID, publishTime, dirty));
+  }
+
+
+  private void deleteElementHierarchy(
+      SessionContext context, ElementRepository elementRepository,
+      ElementSynchronizationStateRepository elementSyncStateRepository,
+      ElementEntityContext elementContext, ElementEntity element) {
+
+    Optional<ElementEntity> retrieved = elementRepository.get(context, elementContext, element);
+    if (!retrieved.isPresent()) {
+      return;
+    }
+    retrieved.get().getSubElementIds().stream()
+        .map(ElementEntity::new)
+        .forEach(subElementEntity -> deleteElementHierarchy(
+            context, elementRepository, elementSyncStateRepository, elementContext,
+            subElementEntity));
+
+    // only for the first one the parentId will populated (so it'll be removed from its parent)
+    elementRepository.delete(context, elementContext, element);
+    handleDeletedElementSyncState(context, elementSyncStateRepository, elementContext, element);
+  }
+
+  private void handleDeletedElementSyncState(SessionContext context,
+                                             ElementSynchronizationStateRepository elementSyncStateRepository,
+                                             ElementEntityContext elementContext,
+                                             ElementEntity element) {
+    SynchronizationStateEntity elementSyncState = new SynchronizationStateEntity(element.getId(),
+        REVISION_ID);
+    if (elementSyncStateRepository.get(context, elementContext, elementSyncState).
+        orElseThrow(
+            () -> new IllegalStateException("Synchronization state must exist for an element"))
+        .getPublishTime() == null) {
+      elementSyncStateRepository.delete(context, elementContext, elementSyncState);
+    } else {
+      elementSyncStateRepository.markAsDirty(context, elementContext, elementSyncState);
+    }
+  }
+
+  private boolean isElementChanged(SessionContext context,
+                                   ElementEntityContext elementContext,
+                                   ElementEntity newElement) {
+    return getElementHash(context, elementContext, new ElementEntity(newElement.getId()))
+        .map(existingHash -> !newElement.getElementHash().equals(existingHash))
+        .orElse(true);
+  }
+
+  private Optional<Id> getElementHash(SessionContext context,
+                                      ElementEntityContext elementEntityContext,
+                                      ElementEntity element) {
+    return getElementRepository(context).getHash(context, elementEntityContext, element);
+  }
+
+  protected ElementRepository getElementRepository(SessionContext context) {
+    return ElementRepositoryFactory.getInstance().createInterface(context);
+  }
+
+  protected ElementSynchronizationStateRepository getElementSyncStateRepository(
+      SessionContext context) {
+    return ElementSynchronizationStateRepositoryFactory.getInstance().createInterface(context);
+  }
+
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementPublicStoreImpl.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementPublicStoreImpl.java
new file mode 100644
index 0000000000..d946a529ce
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementPublicStoreImpl.java
@@ -0,0 +1,189 @@
+package org.openecomp.core.zusammen.plugin.collaboration.impl;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.Space;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.plugin.statestore.cassandra.dao.types.ElementEntityContext;
+import org.openecomp.core.zusammen.plugin.collaboration.ElementPublicStore;
+import org.openecomp.core.zusammen.plugin.dao.ElementRepository;
+import org.openecomp.core.zusammen.plugin.dao.ElementRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.ElementSynchronizationStateRepository;
+import org.openecomp.core.zusammen.plugin.dao.ElementSynchronizationStateRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getSpaceName;
+
+public class ElementPublicStoreImpl implements ElementPublicStore {
+
+  @Override
+  public Optional<ElementEntity> get(SessionContext context,
+                                     ElementContext elementContext, Id elementId) {
+    return getElementRepository(context)
+        .get(context, new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext),
+            new ElementEntity(elementId));
+  }
+
+  @Override
+  public Optional<ElementEntity> getDescriptor(SessionContext context,
+                                               ElementContext elementContext, Id elementId) {
+    return getElementRepository(context).getDescriptor(context,
+        new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext),
+        new ElementEntity(elementId));
+  }
+
+  @Override
+  public Collection<SynchronizationStateEntity> listSynchronizationStates(
+      SessionContext context, ElementContext elementContext) {
+    ElementEntityContext entityContext = new ElementEntityContext(getSpaceName
+        (context, Space.PUBLIC), elementContext);
+
+    ElementSynchronizationStateRepository elementSyncStateRepository =
+        getElementSyncStateRepository(context);
+    Map<Id, Id> ids = getElementRepository(context).listIds(context, entityContext);
+
+    Collection<SynchronizationStateEntity> synchronizationStateEntities = new HashSet<>();
+    for (Map.Entry<Id, Id> elementEntry : ids.entrySet()) {
+      Optional<SynchronizationStateEntity> synchronizationStateEntity = elementSyncStateRepository.
+          get(context, entityContext, new SynchronizationStateEntity(elementEntry.getKey(),
+              elementEntry.getValue()));
+      if (synchronizationStateEntity.isPresent()) {
+        synchronizationStateEntities.add(synchronizationStateEntity.get());
+      } else {
+        /*throw new IllegalStateException(String.format(
+            "list Synchronization States error: " + "element %s revision %s, which appears as an " +
+                "element of " +
+                "item" +
+                " %s version %s, does not exist",
+            elementEntry.getKey(), elementEntry.getValue(), elementContext.getItemId().getValue(),
+            elementContext.getVersionId().getValue()));*/
+      }
+    }
+
+    return synchronizationStateEntities;
+  }
+
+  @Override
+  public void create(SessionContext context, ElementContext elementContext,
+                     ElementEntity element, Date publishTime) {
+    ElementEntityContext publicContext =
+        new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
+
+
+    if (element.getParentId() != null) {
+      createParentElement(context, elementContext, element.getParentId(), publishTime);
+    }
+    getElementRepository(context).create(context, publicContext, element);
+    getElementSyncStateRepository(context).create(context, publicContext,
+        new SynchronizationStateEntity(element.getId(), elementContext.getRevisionId(),
+            publishTime, false));
+  }
+
+  @Override
+  public void update(SessionContext context, ElementContext elementContext,
+                     ElementEntity element, Date publishTime) {
+    //todo - update in public should be create new entry with new revision_id in public - this is a
+    // new revision
+    ElementEntityContext publicContext =
+        new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
+
+    Optional<ElementEntity> publicElement = getElementRepository(context).get(context,
+        publicContext, new ElementEntity(element.getId()));
+    if (publicElement.isPresent()) {
+      getElementRepository(context).update(context, publicContext, element);
+    } else {
+       publicElement = get(context,new ElementContext(publicContext.getItemId(),publicContext
+           .getVersionId()),element.getId());
+       element.setSubElementIds(publicElement.get().getSubElementIds());
+      getElementRepository(context).create(context, publicContext, element);
+    }
+    getElementSyncStateRepository(context).update(context, publicContext,
+        new SynchronizationStateEntity(element.getId(), elementContext.getRevisionId(), publishTime,
+            false));
+  }
+
+  @Override
+  public void delete(SessionContext context, ElementContext elementContext,
+                     ElementEntity element, Date publishTime) {
+    ElementEntityContext publicContext =
+        new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
+
+    if (element.getParentId() != null) {
+      Optional<ElementEntity> parentElement = get(context, elementContext, element.getParentId());
+      if (parentElement.isPresent()) {
+        createParentElement(context, elementContext, element.getParentId(), publishTime);
+      }
+    }
+
+    getElementRepository(context).delete(context, publicContext, element);
+    getElementSyncStateRepository(context)
+        .delete(context, publicContext, new SynchronizationStateEntity(element.getId(),
+            elementContext.getRevisionId()));
+  }
+
+  @Override
+  public Map<Id, Id> listIds(SessionContext context, ElementContext elementContext) {
+
+    return getElementRepository(context)
+        .listIds(context,
+            new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext));
+
+  }
+
+  private void createParentElement(SessionContext context, ElementContext elementContext,
+                                   Id parentElementId, Date publishTime
+  ) {
+    ElementEntityContext publicContext =
+        new ElementEntityContext(getSpaceName(context, Space.PUBLIC), elementContext);
+
+    Optional<ElementEntity> parentElement =
+        getElementRepository(context).get(context, new ElementEntityContext
+                (publicContext.getSpace(), publicContext.getItemId(), publicContext.getVersionId(),
+                    elementContext.getRevisionId()),
+            new ElementEntity(parentElementId));
+    if(parentElement.isPresent()) {
+      update(context, elementContext, parentElement.get(), publishTime);
+    }
+
+
+   /* Id elementRevisionId = getElementRevision(context, publicContext, elementContext.getRevisionId()
+        , parentElementId);
+
+    if (elementRevisionId != null && !elementRevisionId.equals(elementContext.getRevisionId())) {
+      Optional<ElementEntity> parentElement =
+          getElementRepository(context).get(context, new ElementEntityContext
+                  (publicContext.getSpace(), publicContext.getItemId(), publicContext.getVersionId(),
+                      elementContext.getRevisionId()),
+              new ElementEntity(parentElementId));
+      elementRevisionId = getElementRevision(context, publicContext, elementContext.getRevisionId()
+          , parentElement.get().getId());
+      if (elementRevisionId != null) {
+        update(context, elementContext, parentElement.get(), publishTime);
+      } else {
+        create(context, elementContext, parentElement.get(), publishTime);
+      }
+
+    }*/
+  }
+
+
+
+
+  protected ElementRepository getElementRepository(SessionContext context) {
+    return ElementRepositoryFactory.getInstance().createInterface(context);
+  }
+
+  protected ElementSynchronizationStateRepository getElementSyncStateRepository(
+      SessionContext context) {
+    return ElementSynchronizationStateRepositoryFactory.getInstance().createInterface(context);
+  }
+
+
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementStageStoreImpl.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementStageStoreImpl.java
new file mode 100644
index 0000000000..f6c29432df
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/ElementStageStoreImpl.java
@@ -0,0 +1,133 @@
+package org.openecomp.core.zusammen.plugin.collaboration.impl;
+
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Action;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.datatypes.item.Resolution;
+import com.amdocs.zusammen.plugin.statestore.cassandra.dao.types.ElementEntityContext;
+import org.openecomp.core.zusammen.plugin.collaboration.ElementStageStore;
+import org.openecomp.core.zusammen.plugin.dao.ElementStageRepository;
+import org.openecomp.core.zusammen.plugin.dao.ElementStageRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.types.ElementEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.StageEntity;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateElementContext;
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateSpaceName;
+
+public class ElementStageStoreImpl implements ElementStageStore {
+
+  @Override
+  public Collection<ElementEntity> listIds(SessionContext context, ElementContext elementContext) {
+    return getElementStageRepository(context)
+        .listIds(context, new ElementEntityContext(getPrivateSpaceName(context),
+            getPrivateElementContext(elementContext)));
+  }
+
+  @Override
+  public Optional<StageEntity<ElementEntity>> get(SessionContext context,
+                                                  ElementContext elementContext,
+                                                  ElementEntity element) {
+    return getElementStageRepository(context).get(context,
+        new ElementEntityContext(getPrivateSpaceName(context),
+            getPrivateElementContext(elementContext)),
+        element);
+  }
+
+  @Override
+  public Optional<StageEntity<ElementEntity>> getConflicted(SessionContext context,
+                                                            ElementContext elementContext,
+                                                            ElementEntity element) {
+    return get(context, elementContext, element).filter(StageEntity::isConflicted);
+  }
+
+  @Override
+  public boolean hasConflicts(SessionContext context, ElementContext elementContext) {
+    return !getElementStageRepository(context).listConflictedIds(context,
+        new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext(elementContext))).isEmpty();
+  }
+
+  @Override
+  public Collection<StageEntity<ElementEntity>> listConflictedDescriptors(SessionContext context,
+                                                                          ElementContext elementContext) {
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext
+            (elementContext));
+    ElementStageRepository elementStageRepository = getElementStageRepository(context);
+
+    return elementStageRepository.listConflictedIds(context, privateContext).stream()
+        .map(conflictedElement -> elementStageRepository
+            .getDescriptor(context, privateContext, conflictedElement).get())
+        .collect(Collectors.toList());
+  }
+
+  @Override
+  public void create(SessionContext context, ElementContext elementContext,
+                     StageEntity<ElementEntity> elementStage) {
+    getElementStageRepository(context)
+        .create(context,
+            new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext(elementContext)),
+            elementStage);
+  }
+
+  @Override
+  public void delete(SessionContext context, ElementContext elementContext, ElementEntity element) {
+    getElementStageRepository(context)
+        .delete(context,
+            new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext(elementContext)),
+            element);
+  }
+
+
+  @Override
+  public void resolveConflict(SessionContext context, ElementContext elementContext,
+                              ElementEntity element, Resolution resolution) {
+    Optional<StageEntity<ElementEntity>> stagedElement =
+        getConflicted(context, elementContext, element);
+    if (!stagedElement.isPresent()) {
+      return;
+    }
+
+    ElementEntityContext privateContext =
+        new ElementEntityContext(getPrivateSpaceName(context), getPrivateElementContext
+            (elementContext));
+
+    switch (resolution) {
+      case YOURS:
+        resolveConflictByYours(context, privateContext, stagedElement.get());
+        break;
+      case THEIRS:
+        resolveConflictByTheirs(context, privateContext, stagedElement.get());
+        break;
+      case OTHER: // other = data updates only? no data deletions? if so, then:
+        // conflicted = false
+        // element = the input of resolve
+        // action = update
+        throw new UnsupportedOperationException("'Other' conflict resolution is not yet supported");
+      default:
+        break;
+    }
+  }
+
+  private void resolveConflictByYours(SessionContext context, ElementEntityContext privateContext,
+                                      StageEntity<ElementEntity> stagedElement) {
+    getElementStageRepository(context)
+        .markAsNotConflicted(context, privateContext, stagedElement.getEntity(), Action.IGNORE);
+    stagedElement.getConflictDependents().forEach(conflictDependant ->
+        getElementStageRepository(context)
+            .markAsNotConflicted(context, privateContext, conflictDependant, Action.IGNORE));
+  }
+
+  private void resolveConflictByTheirs(SessionContext context, ElementEntityContext privateContext,
+                                       StageEntity<ElementEntity> stagedElement) {
+    getElementStageRepository(context)
+        .markAsNotConflicted(context, privateContext, stagedElement.getEntity());
+  }
+
+  protected ElementStageRepository getElementStageRepository(SessionContext context) {
+    return ElementStageRepositoryFactory.getInstance().createInterface(context);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionPrivateStoreImpl.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionPrivateStoreImpl.java
new file mode 100644
index 0000000000..11e61ab5a9
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionPrivateStoreImpl.java
@@ -0,0 +1,117 @@
+package org.openecomp.core.zusammen.plugin.collaboration.impl;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import org.openecomp.core.zusammen.plugin.collaboration.VersionPrivateStore;
+import org.openecomp.core.zusammen.plugin.dao.VersionDao;
+import org.openecomp.core.zusammen.plugin.dao.VersionDaoFactory;
+import org.openecomp.core.zusammen.plugin.dao.VersionSynchronizationStateRepository;
+import org.openecomp.core.zusammen.plugin.dao.VersionSynchronizationStateRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionContext;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Date;
+import java.util.Optional;
+
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateSpaceName;
+
+public class VersionPrivateStoreImpl implements VersionPrivateStore {
+
+  Id revisionId = Id.ZERO;
+
+  @Override
+  public Optional<VersionEntity> get(SessionContext context, Id itemId, Id versionId) {
+    return getVersionDao(context).get(context, getPrivateSpaceName(context), itemId, versionId);
+  }
+
+  @Override
+  public Optional<SynchronizationStateEntity> getSynchronizationState(SessionContext context,
+                                                                      Id itemId, Id versionId) {
+
+    return getVersionSyncStateRepository(context)
+        .get(context, new VersionContext(getPrivateSpaceName(context), itemId),
+            new SynchronizationStateEntity(versionId, revisionId));
+  }
+
+  @Override
+  public void create(SessionContext context, Id itemId, VersionEntity version) {
+    String privateSpace = getPrivateSpaceName(context);
+
+
+    getVersionDao(context).create(context, privateSpace, itemId, version);
+    getVersionSyncStateRepository(context).create(context, new VersionContext(privateSpace,
+            itemId),
+        new SynchronizationStateEntity(version.getId(), revisionId, null, true));
+  }
+
+  @Override
+  public void update(SessionContext context, Id itemId, VersionEntity version) {
+
+    getVersionDao(context)
+        .updateModificationTime(context, getPrivateSpaceName(context), itemId, version.getId(),
+            version.getModificationTime());
+  }
+
+  @Override
+  public void update(SessionContext context, Id itemId, VersionEntity version, Date publishTime,
+                     boolean dirty) {
+    getVersionSyncStateRepository(context).updatePublishTime(context,
+        new VersionContext(getPrivateSpaceName(context), itemId),
+        new SynchronizationStateEntity(version.getId(), revisionId, publishTime, dirty));
+  }
+
+  @Override
+  public void delete(SessionContext context, Id itemId, VersionEntity version) {
+    String privateSpace = getPrivateSpaceName(context);
+
+    getVersionDao(context).delete(context, privateSpace, itemId, version.getId());
+    getVersionSyncStateRepository(context).delete(context, new VersionContext(privateSpace,
+            itemId),
+        new SynchronizationStateEntity(version.getId(), revisionId));
+  }
+
+  @Override
+  public void markAsPublished(SessionContext context, Id itemId, Id versionId, Date publishTime) {
+    getVersionSyncStateRepository(context)
+        .updatePublishTime(context, new VersionContext(getPrivateSpaceName(context), itemId),
+            new SynchronizationStateEntity(versionId, revisionId, publishTime, false));
+  }
+
+  @Override
+  public void commitStagedCreate(SessionContext context, Id itemId, VersionEntity version,
+                                 Date publishTime) {
+    String privateSpace = getPrivateSpaceName(context);
+
+    getVersionDao(context).create(context, privateSpace, itemId, version);
+    getVersionSyncStateRepository(context).create(context, new VersionContext(privateSpace,
+            itemId),
+        new SynchronizationStateEntity(version.getId(), revisionId, publishTime, false));
+  }
+
+  @Override
+  public void commitStagedUpdate(SessionContext context, Id itemId, VersionEntity version,
+                                 Date publishTime) {
+    update(context, itemId, version, publishTime, false);
+  }
+
+  @Override
+  public void commitStagedIgnore(SessionContext context, Id itemId, VersionEntity version,
+                                 Date publishTime) {
+    getVersionSyncStateRepository(context).updatePublishTime(context,
+        new VersionContext(getPrivateSpaceName(context), itemId),
+        new SynchronizationStateEntity(version.getId(), revisionId, publishTime, false));
+  }
+
+
+
+
+  protected VersionDao getVersionDao(SessionContext context) {
+    return VersionDaoFactory.getInstance().createInterface(context);
+  }
+
+  protected VersionSynchronizationStateRepository getVersionSyncStateRepository(
+      SessionContext context) {
+    return VersionSynchronizationStateRepositoryFactory.getInstance().createInterface(context);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionPublicStoreImpl.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionPublicStoreImpl.java
new file mode 100644
index 0000000000..aa628eb706
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionPublicStoreImpl.java
@@ -0,0 +1,135 @@
+package org.openecomp.core.zusammen.plugin.collaboration.impl;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.Space;
+import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
+import com.amdocs.zusammen.datatypes.itemversion.Revision;
+import org.openecomp.core.zusammen.plugin.collaboration.VersionPublicStore;
+import org.openecomp.core.zusammen.plugin.dao.VersionDao;
+import org.openecomp.core.zusammen.plugin.dao.VersionDaoFactory;
+import org.openecomp.core.zusammen.plugin.dao.VersionSynchronizationStateRepository;
+import org.openecomp.core.zusammen.plugin.dao.VersionSynchronizationStateRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.types.SynchronizationStateEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionContext;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getSpaceName;
+
+public class VersionPublicStoreImpl implements VersionPublicStore {
+  @Override
+  public Optional<VersionEntity> get(SessionContext context, Id itemId, Id versionId) {
+    return getVersionDao(context)
+        .get(context, getSpaceName(context, Space.PUBLIC), itemId, versionId);
+  }
+
+  @Override
+  public Optional<SynchronizationStateEntity> getSynchronizationState(SessionContext context,
+                                                                      Id itemId, Id versionId) {
+    Id revisionId = getLastItemVersionRevision(context, itemId,
+        versionId);
+    if (revisionId == null) {
+      return Optional.empty();
+    }
+
+    return getVersionSyncStateRepository(context)
+        .get(context, new VersionContext(getSpaceName(context, Space.PUBLIC), itemId),
+            new SynchronizationStateEntity(versionId, revisionId));
+  }
+
+
+  @Override
+  public void create(SessionContext context, Id itemId, VersionEntity version, Id revisionId,
+                     Map<Id, Id> versionElementIds, Date
+                         publishTime, String message) {
+    String publicSpace = getSpaceName(context, Space.PUBLIC);
+
+    getVersionDao(context).create(context, publicSpace, itemId, version);
+
+    getVersionDao(context).createVersionElements(context, publicSpace, itemId, version.getId(),
+        revisionId, versionElementIds, publishTime,message);
+
+    getVersionSyncStateRepository(context).create(context, new VersionContext(publicSpace,
+            itemId),
+        new SynchronizationStateEntity(version.getId(), revisionId, publishTime, false));
+  }
+
+  @Override
+  public void update(SessionContext context, Id itemId, VersionEntity version,
+                     Id revisionId, Map<Id, Id> versionElementIds, Date publishTime, String message) {
+    String publicSpace = getSpaceName(context, Space.PUBLIC);
+
+    getVersionDao(context).
+        createVersionElements(context, publicSpace, itemId, version.getId(),
+            revisionId, versionElementIds, publishTime,message);
+
+    getVersionSyncStateRepository(context).
+        updatePublishTime(context, new VersionContext(publicSpace, itemId),
+            new SynchronizationStateEntity(version.getId(), revisionId, publishTime, false));
+  }
+
+  @Override
+  public boolean checkHealth(SessionContext context) {
+    return getVersionDao(context).checkHealth(context);
+  }
+
+  @Override
+  public ItemVersionRevisions listItemVersionRevisions(SessionContext context, Id itemId,
+                                                       Id versionId) {
+    VersionContext entityContext = new VersionContext(getSpaceName(context, Space.PUBLIC), itemId);
+    List<SynchronizationStateEntity> versionRevisions = getVersionSyncStateRepository(context)
+        .list(context, entityContext, new VersionEntity(versionId));
+
+    if (versionRevisions == null || versionRevisions.size() == 0) {
+      return null;
+    }
+
+    versionRevisions.sort(new Comparator<SynchronizationStateEntity>() {
+      @Override
+      public int compare(SynchronizationStateEntity o1, SynchronizationStateEntity o2) {
+        if (o1.getPublishTime().after(o2.getPublishTime())) {
+          return -1;
+        } else {
+          return 1;
+        }
+      }
+    });
+    ItemVersionRevisions itemVersionRevisions = new ItemVersionRevisions();
+    versionRevisions.forEach(synchronizationStateEntity -> itemVersionRevisions.addChange
+        (convertSyncState2Revision(synchronizationStateEntity)));
+    return itemVersionRevisions;
+  }
+
+  private Revision convertSyncState2Revision(
+      SynchronizationStateEntity synchronizationStateEntity) {
+    Revision revision = new Revision();
+    revision.setRevisionId(synchronizationStateEntity.getRevisionId());
+    revision.setTime(synchronizationStateEntity.getPublishTime());
+    revision.setMessage(synchronizationStateEntity.getMessage());
+    revision.setUser(synchronizationStateEntity.getUser());
+    return revision;
+  }
+
+
+  private Id getLastItemVersionRevision(SessionContext context, Id itemId, Id versionId) {
+
+    ItemVersionRevisions versionRevisions = listItemVersionRevisions(context, itemId, versionId);
+    if(versionRevisions ==null ) return null;
+    return versionRevisions.getItemVersionRevisions().get(0).getRevisionId();
+  }
+
+  protected VersionDao getVersionDao(SessionContext context) {
+    return VersionDaoFactory.getInstance().createInterface(context);
+  }
+
+  protected VersionSynchronizationStateRepository getVersionSyncStateRepository(
+      SessionContext context) {
+    return VersionSynchronizationStateRepositoryFactory.getInstance().createInterface(context);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionStageStoreImpl.java b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionStageStoreImpl.java
new file mode 100644
index 0000000000..dac9d257ea
--- /dev/null
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-zusammen-lib/openecomp-zusammen-plugin/src/main/java/org/openecomp/core/zusammen/plugin/collaboration/impl/VersionStageStoreImpl.java
@@ -0,0 +1,39 @@
+package org.openecomp.core.zusammen.plugin.collaboration.impl;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import org.openecomp.core.zusammen.plugin.collaboration.VersionStageStore;
+import org.openecomp.core.zusammen.plugin.dao.VersionStageRepository;
+import org.openecomp.core.zusammen.plugin.dao.VersionStageRepositoryFactory;
+import org.openecomp.core.zusammen.plugin.dao.types.StageEntity;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionContext;
+import org.openecomp.core.zusammen.plugin.dao.types.VersionEntity;
+
+import java.util.Optional;
+
+import static org.openecomp.core.zusammen.plugin.ZusammenPluginUtil.getPrivateSpaceName;
+
+public class VersionStageStoreImpl implements VersionStageStore {
+  @Override
+  public Optional<StageEntity<VersionEntity>> get(SessionContext context, Id itemId,
+                                                  VersionEntity versionEntity) {
+    return getVersionStageRepository(context)
+        .get(context, new VersionContext(getPrivateSpaceName(context), itemId), versionEntity);
+  }
+
+  @Override
+  public void create(SessionContext context, Id itemId, StageEntity<VersionEntity> versionStage) {
+    getVersionStageRepository(context)
+        .create(context, new VersionContext(getPrivateSpaceName(context), itemId), versionStage);
+  }
+
+  @Override
+  public void delete(SessionContext context, Id itemId, VersionEntity version) {
+    getVersionStageRepository(context)
+        .delete(context, new VersionContext(getPrivateSpaceName(context), itemId), version);
+  }
+
+  protected VersionStageRepository getVersionStageRepository(SessionContext context) {
+    return VersionStageRepositoryFactory.getInstance().createInterface(context);
+  }
+}