Add collaboration feature

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

18 files changed, 837 insertions, 0 deletions

diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/pom.xml b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/pom.xml
new file mode 100644
index 0000000000..413cae7933
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/pom.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+
+    <parent>
+        <groupId>org.openecomp.sdc</groupId>
+        <artifactId>openecomp-conflict-lib</artifactId>
+        <version>1.2.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <artifactId>openecomp-conflict-api</artifactId>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>org.openecomp.sdc.core</groupId>
+            <artifactId>openecomp-facade-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc.core</groupId>
+            <artifactId>openecomp-facade-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-sdc-versioning-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+
+
+</project>
\ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/ItemMergeHandler.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/ItemMergeHandler.java
new file mode 100644
index 0000000000..189e4cedd9
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/ItemMergeHandler.java
@@ -0,0 +1,27 @@
+package org.openecomp.conflicts;
+
+import org.openecomp.conflicts.types.Conflict;
+import org.openecomp.conflicts.types.ConflictResolution;
+import org.openecomp.conflicts.types.ItemVersionConflict;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+import java.util.Optional;
+
+public interface ItemMergeHandler {
+
+  boolean isConflicted(String itemId, Version version);
+
+  void finalizeMerge(String itemId, Version version);
+
+  void postListConflicts(String itemId, Version version, ItemVersionConflict conflicts);
+
+  Optional<Conflict> getConflict(String itemId, Version version, String conflictId);
+
+  void postGetConflict(String itemId, Version version, Conflict conflict);
+
+  void preResolveConflict(String itemId, Version version, String conflictId,
+                          ConflictResolution resolution);
+
+  boolean resolveConflict(String itemId, Version version, String conflictId,
+                          ConflictResolution resolution);
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactory.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactory.java
new file mode 100644
index 0000000000..8fb0a48870
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactory.java
@@ -0,0 +1,16 @@
+package org.openecomp.conflicts;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+import java.util.Optional;
+
+public abstract class ItemMergeHandlerFactory
+    extends AbstractComponentFactory<ItemMergeHandler> {
+
+  public static ItemMergeHandlerFactory getInstance() {
+    return AbstractFactory.getInstance(ItemMergeHandlerFactory.class);
+  }
+
+  public abstract Optional<ItemMergeHandler> createInterface(String itemId);
+}
\ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/dao/ConflictsDao.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/dao/ConflictsDao.java
new file mode 100644
index 0000000000..273233a12c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/dao/ConflictsDao.java
@@ -0,0 +1,18 @@
+package org.openecomp.conflicts.dao;
+
+import org.openecomp.conflicts.types.Conflict;
+import org.openecomp.conflicts.types.ConflictResolution;
+import org.openecomp.conflicts.types.ItemVersionConflict;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+public interface ConflictsDao {
+
+  boolean isConflicted(String itemId, Version version);
+
+  ItemVersionConflict getConflict(String itemId, Version version);
+
+  Conflict getConflict(String itemId, Version version, String conflictId);
+
+  void resolveConflict(String itemId, Version version, String conflictId,
+                       ConflictResolution conflictResolution);
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/dao/ConflictsDaoFactory.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/dao/ConflictsDaoFactory.java
new file mode 100644
index 0000000000..e4c88d6279
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/dao/ConflictsDaoFactory.java
@@ -0,0 +1,32 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.conflicts.dao;
+
+import org.openecomp.core.factory.api.AbstractComponentFactory;
+import org.openecomp.core.factory.api.AbstractFactory;
+
+public abstract class ConflictsDaoFactory
+    extends AbstractComponentFactory<ConflictsDao> {
+
+  public static ConflictsDaoFactory getInstance() {
+    return AbstractFactory.getInstance(ConflictsDaoFactory.class);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/Conflict.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/Conflict.java
new file mode 100644
index 0000000000..bc324af1dd
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/Conflict.java
@@ -0,0 +1,30 @@
+package org.openecomp.conflicts.types;
+
+import org.openecomp.sdc.datatypes.model.ElementType;
+
+public class Conflict<T> extends ConflictInfo {
+  private T yours;
+  private T theirs;
+
+  public Conflict(String id, ElementType type, String name) {
+    super(id, type, name);
+  }
+
+  public T getYours() {
+    return yours;
+  }
+
+  public void setYours(T yours) {
+    this.yours = yours;
+  }
+
+  public T getTheirs() {
+    return theirs;
+  }
+
+  public void setTheirs(T theirs) {
+    this.theirs = theirs;
+  }
+
+
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ConflictInfo.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ConflictInfo.java
new file mode 100644
index 0000000000..ff58f00121
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ConflictInfo.java
@@ -0,0 +1,39 @@
+package org.openecomp.conflicts.types;
+
+import org.openecomp.sdc.datatypes.model.ElementType;
+
+public class ConflictInfo {
+  private String id;
+  private ElementType type;
+  private String name;
+
+  public ConflictInfo(String id, ElementType type, String name) {
+    this.id = id;
+    this.type = type;
+    this.name = name;
+  }
+
+  public String getId() {
+    return id;
+  }
+
+  public void setId(String id) {
+    this.id = id;
+  }
+
+  public ElementType getType() {
+    return type;
+  }
+
+  public void setType(ElementType type) {
+    this.type = type;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ConflictResolution.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ConflictResolution.java
new file mode 100644
index 0000000000..961f9080d9
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ConflictResolution.java
@@ -0,0 +1,32 @@
+package org.openecomp.conflicts.types;
+
+import java.util.Map;
+
+public class ConflictResolution {
+  private Resolution resolution;
+  // sits in lower level...
+  private Map<String, Object> otherResolution;
+
+  public ConflictResolution() {
+  }
+
+  public ConflictResolution(Resolution resolution) {
+    this.resolution = resolution;
+  }
+
+  public Resolution getResolution() {
+    return resolution;
+  }
+
+  public void setResolution(Resolution resolution) {
+    this.resolution = resolution;
+  }
+
+  public Map<String, Object> getOtherResolution() {
+    return otherResolution;
+  }
+
+  public void setOtherResolution(Map<String, Object> otherResolution) {
+    this.otherResolution = otherResolution;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ItemVersionConflict.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ItemVersionConflict.java
new file mode 100644
index 0000000000..a4749f3990
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/ItemVersionConflict.java
@@ -0,0 +1,31 @@
+package org.openecomp.conflicts.types;
+
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class ItemVersionConflict {
+  private Conflict<Version> versionConflict;
+  private Collection<ConflictInfo> elementConflicts = new ArrayList<>();
+
+  public Conflict<Version> getVersionConflict() {
+    return versionConflict;
+  }
+
+  public void setVersionConflict(Conflict<Version> versionConflict) {
+    this.versionConflict = versionConflict;
+  }
+
+  public Collection<ConflictInfo> getElementConflicts() {
+    return elementConflicts;
+  }
+
+  public void setElementConflicts(Collection<ConflictInfo> elementConflicts) {
+    this.elementConflicts = elementConflicts;
+  }
+
+  public void addElementConflictInfo(ConflictInfo conflictInfo) {
+    elementConflicts.add(conflictInfo);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/Resolution.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/Resolution.java
new file mode 100644
index 0000000000..2222f81c70
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-api/src/main/java/org/openecomp/conflicts/types/Resolution.java
@@ -0,0 +1,5 @@
+package org.openecomp.conflicts.types;
+
+public enum Resolution {
+  THEIRS,YOURS,OTHER
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/pom.xml b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/pom.xml
new file mode 100644
index 0000000000..ddeb03df53
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/pom.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.openecomp.sdc</groupId>
+        <artifactId>openecomp-conflict-lib</artifactId>
+        <version>1.2.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <artifactId>openecomp-conflict-core</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-conflict-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc.core</groupId>
+            <artifactId>openecomp-zusammen-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-sdc-vendor-software-product-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openecomp.sdc</groupId>
+            <artifactId>openecomp-sdc-vendor-license-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+</project>
\ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactoryImpl.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactoryImpl.java
new file mode 100644
index 0000000000..4c981acee4
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/ItemMergeHandlerFactoryImpl.java
@@ -0,0 +1,40 @@
+package org.openecomp.conflicts;
+
+import org.openecomp.conflicts.dao.ConflictsDaoFactory;
+import org.openecomp.conflicts.impl.VspMergeHandler;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.datatypes.model.ItemType;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDaoFactory;
+import org.openecomp.sdc.versioning.ItemManagerFactory;
+import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder;
+import org.openecomp.sdc.versioning.types.Item;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class ItemMergeHandlerFactoryImpl extends ItemMergeHandlerFactory {
+  // TODO: 11/1/2017 read this map from configuration, move Vsp merge handler to vsp lib, rearrange lib deps
+  private static final Map<ItemType, ItemMergeHandler> MERGE_HANDLER_BY_ITEM_TYPE =
+      new HashMap<>();
+
+  static {
+    MERGE_HANDLER_BY_ITEM_TYPE.put(ItemType.vsp,
+        new VspMergeHandler(ConflictsDaoFactory.getInstance().createInterface(),
+            VspMergeDaoFactory.getInstance().createInterface()));
+  }
+
+  @Override
+  public Optional<ItemMergeHandler> createInterface(String itemId) {
+    Item item = ItemManagerFactory.getInstance().createInterface().get(itemId);
+    if (item == null) {
+      throw new CoreException(new EntityNotExistErrorBuilder("", itemId).build());
+    }
+    return Optional.ofNullable(MERGE_HANDLER_BY_ITEM_TYPE.get(ItemType.valueOf(item.getType())));
+  }
+
+  @Override
+  public ItemMergeHandler createInterface() {
+    return null; // call the one with the item id arg
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoFactoryImpl.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoFactoryImpl.java
new file mode 100644
index 0000000000..7cb3598b9d
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoFactoryImpl.java
@@ -0,0 +1,17 @@
+package org.openecomp.conflicts.dao.impl.zusammen;
+
+
+import org.openecomp.conflicts.dao.ConflictsDao;
+import org.openecomp.conflicts.dao.ConflictsDaoFactory;
+import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory;
+
+public class ConflictsDaoFactoryImpl extends ConflictsDaoFactory {
+
+  private static final ConflictsDao INSTANCE = new
+      ConflictsDaoImpl(ZusammenAdaptorFactory.getInstance().createInterface());
+
+  @Override
+  public ConflictsDao createInterface() {
+    return INSTANCE;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoImpl.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoImpl.java
new file mode 100644
index 0000000000..eac1be3b8e
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ConflictsDaoImpl.java
@@ -0,0 +1,175 @@
+package org.openecomp.conflicts.dao.impl.zusammen;
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementConflict;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.datatypes.item.Item;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import com.amdocs.zusammen.datatypes.item.Resolution;
+import org.openecomp.conflicts.dao.ConflictsDao;
+import org.openecomp.conflicts.types.Conflict;
+import org.openecomp.conflicts.types.ConflictResolution;
+import org.openecomp.conflicts.types.ItemVersionConflict;
+import org.openecomp.convertor.ElementConvertor;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.sdc.datatypes.model.ElementType;
+import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToEntitlementPoolConvertor;
+import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToFeatureGroupConvertor;
+import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToLicenseAgreementConvertor;
+import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToLicenseKeyGroupConvertor;
+import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToLimitConvertor;
+import org.openecomp.sdc.vendorlicense.dao.impl.zusammen.convertor.ElementToVLMGeneralConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComponentConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComponentDependencyModelConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToCompositionEntityConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToComputeConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToImageConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToMonitoringUploadMapConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToNetworkConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToNicConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToOrchestrationTemplateCandidateMapConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToProcessConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToServiceModelMapConvertor;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.impl.zusammen.convertor.ElementToVSPGeneralConvertor;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+import static org.openecomp.core.zusammen.api.ZusammenUtil.buildElement;
+import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
+
+public class ConflictsDaoImpl implements ConflictsDao {
+  private final ZusammenAdaptor zusammenAdaptor;
+
+  public ConflictsDaoImpl(ZusammenAdaptor zusammenAdaptor) {
+    this.zusammenAdaptor = zusammenAdaptor;
+  }
+
+  @Override
+  public boolean isConflicted(String itemId, Version version) {
+    com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict itemVersionConflict =
+        zusammenAdaptor
+            .getVersionConflict(createSessionContext(), new Id(itemId), new Id(version.getId()));
+    return !(itemVersionConflict == null
+        || (itemVersionConflict.getVersionDataConflict() == null
+        && itemVersionConflict.getElementConflictInfos().isEmpty()));
+  }
+
+  @Override
+  public ItemVersionConflict getConflict(String itemId, Version version) {
+    return new ItemVersionConflictConvertorFromZusammen().convert(itemId, version,
+        zusammenAdaptor
+            .getVersionConflict(createSessionContext(), new Id(itemId), new Id(version.getId())));
+  }
+
+  @Override
+  public Conflict getConflict(String itemId, Version version, String conflictId) {
+    return zusammenAdaptor.getElementConflict(createSessionContext(),
+        new ElementContext(new Id(itemId), new Id(version.getId())), new Id(conflictId))
+        .map(elementConflict -> convertElementConflict(conflictId, elementConflict))
+        .orElse(null);
+  }
+
+  @Override
+  public void resolveConflict(String itemId, Version version, String conflictId,
+                              ConflictResolution conflictResolution) {
+    SessionContext context = createSessionContext();
+    ElementContext elementContext = new ElementContext(new Id(itemId), new Id(version.getId()));
+
+    // TODO: 7/31/2017 when 'OTHER' resolution will be supported - populate zusammen element with it
+    zusammenAdaptor.resolveElementConflict(context, elementContext,
+        buildElement(new Id(conflictId), null),
+        Resolution.valueOf(conflictResolution.getResolution().name()));
+  }
+
+  private Conflict convertElementConflict(String conflictId, ElementConflict elementConflict) {
+    Element element = elementConflict.getLocalElement() == null
+        ? elementConflict.getRemoteElement()
+        : elementConflict.getLocalElement();
+    ElementType elementType = ElementConvertor.getElementType(element);
+
+    Conflict conflict =
+        new Conflict(conflictId, elementType, ElementConvertor.getElementName(element));
+    ElementConvertor convertor = getConvertor(elementType);
+    if (elementConflict.getLocalElement() != null) {
+      conflict.setYours(convertor.convert(elementConflict.getLocalElement()));
+    }
+    if (elementConflict.getRemoteElement() != null) {
+      conflict.setTheirs(convertor.convert(elementConflict.getRemoteElement()));
+    }
+    return conflict;
+  }
+
+  private ElementConvertor getConvertor(ElementType type) {
+    switch (type) {
+      case VendorSoftwareProduct:
+        return new ElementToVSPGeneralConvertor();
+      case Process:
+        return new ElementToProcessConvertor();
+      case Nic:
+        return new ElementToNicConvertor();
+      case Network:
+        return new ElementToNetworkConvertor();
+      case SNMP_POLL:
+      case SNMP_TRAP:
+      case VES_EVENTS:
+        return new ElementToMonitoringUploadMapConvertor();
+      case Image:
+        return new ElementToImageConvertor();
+      case Compute:
+        return new ElementToComputeConvertor();
+      case Component:
+        return new ElementToComponentConvertor();
+      case ComponentDependencies:
+        return new ElementToComponentDependencyModelConvertor();
+      case VendorLicenseModel:
+        return new ElementToVLMGeneralConvertor();
+      case LicenseAgreement:
+        return new ElementToLicenseAgreementConvertor();
+      case FeatureGroup:
+        return new ElementToFeatureGroupConvertor();
+      case LicenseKeyGroup:
+        return new ElementToLicenseKeyGroupConvertor();
+      case EntitlementPool:
+        return new ElementToEntitlementPoolConvertor();
+      case Limit:
+        return new ElementToLimitConvertor();
+      case OrchestrationTemplateCandidate:
+        return new ElementToOrchestrationTemplateCandidateMapConvertor();
+      case ServiceModel:
+        return new ElementToServiceModelMapConvertor();
+      case VSPQuestionnaire:
+      case ImageQuestionnaire:
+      case ComponentQuestionnaire:
+      case ComputeQuestionnaire:
+      case NicQuestionnaire:
+        return new ElementToCompositionEntityConvertor();
+      default:
+        return new EchoConvertor();
+    }
+  }
+
+  public static class EchoConvertor extends ElementConvertor {
+
+    @Override
+    public Object convert(Element element) {
+      return element;
+    }
+
+    @Override
+    public Object convert(Item item) {
+      return item;
+    }
+
+    @Override
+    public Object convert(ElementInfo elementInfo) {
+      return elementInfo;
+    }
+
+    @Override
+    public Object convert(ItemVersion itemVersion) {
+      return null;
+    }
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ItemVersionConflictConvertorFromZusammen.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ItemVersionConflictConvertorFromZusammen.java
new file mode 100644
index 0000000000..4dffaf8231
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/dao/impl/zusammen/ItemVersionConflictConvertorFromZusammen.java
@@ -0,0 +1,73 @@
+package org.openecomp.conflicts.dao.impl.zusammen;
+
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementConflictInfo;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict;
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import com.amdocs.zusammen.datatypes.item.ItemVersionData;
+import com.amdocs.zusammen.datatypes.item.ItemVersionDataConflict;
+import org.openecomp.conflicts.types.Conflict;
+import org.openecomp.conflicts.types.ConflictInfo;
+import org.openecomp.sdc.datatypes.model.ElementType;
+import org.openecomp.sdc.versioning.dao.impl.zusammen.convertor.ItemVersionToVersionConvertor;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.types.ElementPropertyName;
+
+import java.util.stream.Collectors;
+
+public class ItemVersionConflictConvertorFromZusammen {
+  public org.openecomp.conflicts.types.ItemVersionConflict convert(String itemId, Version version,
+                                                                   ItemVersionConflict source) {
+    org.openecomp.conflicts.types.ItemVersionConflict target =
+        new org.openecomp.conflicts.types.ItemVersionConflict();
+
+    target.setVersionConflict(
+        convertVersionDataConflict(itemId, version, source.getVersionDataConflict()));
+    target.setElementConflicts(source.getElementConflictInfos().stream()
+        .map(this::convertElementConflictInfo)
+        .collect(Collectors.toList()));
+
+    return target;
+  }
+
+
+  private Conflict<Version> convertVersionDataConflict(String itemId, Version version,
+                                                       ItemVersionDataConflict versionDataConflict) {
+    if (versionDataConflict == null) {
+      return null;
+    }
+
+    Conflict<Version> conflict =
+        new Conflict<>(version.getId(), ElementType.itemVersion, null);
+
+    ItemVersionToVersionConvertor convertor = new ItemVersionToVersionConvertor();
+    conflict.setYours(convertor.convert(
+        getItemVersion(version.getId(), versionDataConflict.getLocalData())));
+    conflict.setTheirs(convertor.convert(
+        getItemVersion(version.getId(), versionDataConflict.getRemoteData())));
+    return conflict;
+  }
+
+  private ItemVersion getItemVersion(String versionId, ItemVersionData versionData) {
+    if (versionData == null) {
+      return null;
+    }
+    ItemVersion itemVersion = new ItemVersion();
+    itemVersion.setId(new Id(versionId));
+    itemVersion.setData(versionData);
+    return itemVersion;
+  }
+
+  private ConflictInfo convertElementConflictInfo(ElementConflictInfo elementConflictInfo) {
+    ElementInfo elementInfo = elementConflictInfo.getLocalElementInfo() == null
+        ? elementConflictInfo.getRemoteElementInfo()
+        : elementConflictInfo.getLocalElementInfo();
+
+    return new ConflictInfo(elementInfo.getId().getValue(),
+        ElementType
+            .valueOf(elementInfo.getInfo().getProperty(ElementPropertyName.elementType.name())),
+        elementInfo.getInfo().getName());
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/impl/VspMergeHandler.java b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/impl/VspMergeHandler.java
new file mode 100644
index 0000000000..f7d0bca392
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/java/org/openecomp/conflicts/impl/VspMergeHandler.java
@@ -0,0 +1,204 @@
+package org.openecomp.conflicts.impl;
+
+import org.openecomp.conflicts.ItemMergeHandler;
+import org.openecomp.conflicts.dao.ConflictsDao;
+import org.openecomp.conflicts.types.Conflict;
+import org.openecomp.conflicts.types.ConflictInfo;
+import org.openecomp.conflicts.types.ConflictResolution;
+import org.openecomp.conflicts.types.ItemVersionConflict;
+import org.openecomp.conflicts.types.Resolution;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.datatypes.model.ElementType;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VspMergeDao;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.openecomp.sdc.datatypes.model.ElementType.NetworkPackage;
+import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplate;
+import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplateCandidate;
+import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplateCandidateContent;
+import static org.openecomp.sdc.datatypes.model.ElementType.OrchestrationTemplateValidationData;
+import static org.openecomp.sdc.datatypes.model.ElementType.VspModel;
+
+public class VspMergeHandler implements ItemMergeHandler {
+
+  private static final String VSP_MODEL_CONFLICT_ID = "vspModelConflictId";
+  private static final String ELEMENT_CONFLICT_NOT_EXIST_ERR_ID = "ELEMENT_CONFLICT_NOT_EXIST";
+  private static final String ELEMENT_CONFLICT_NOT_EXISTS_MSG =
+      "Item Id %s, version Id %s, element conflict with Id %s does not exists.";
+  private static final Set<ElementType> FILTERED_OUT_TYPES = Stream
+      .of(OrchestrationTemplateCandidateContent, OrchestrationTemplateValidationData)
+      .collect(Collectors.toSet());
+  private static final Map<ElementType, Set<ElementType>> ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES =
+      new HashMap<>();
+
+  static {
+    ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES.put(OrchestrationTemplateCandidate,
+        Collections.singleton(OrchestrationTemplateCandidateContent));
+    ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES.put(OrchestrationTemplate,
+        Collections.singleton(OrchestrationTemplateValidationData));
+  }
+
+  private ConflictsDao conflictsDao;
+  private VspMergeDao vspMergeDao;
+
+  public VspMergeHandler(ConflictsDao conflictsDao, VspMergeDao vspMergeDao) {
+    this.conflictsDao = conflictsDao;
+    this.vspMergeDao = vspMergeDao;
+  }
+
+  @Override
+  public boolean isConflicted(String itemId, Version version) {
+    return vspMergeDao.isVspModelConflicted(itemId, version);
+  }
+
+  @Override
+  public void finalizeMerge(String itemId, Version version) {
+    if (!conflictsDao.isConflicted(itemId, version)) {
+      vspMergeDao.applyVspModelConflictResolution(itemId, version);
+    }
+  }
+
+  @Override
+  public void postListConflicts(String itemId, Version version, ItemVersionConflict conflicts) {
+    List<ConflictInfo> elementConflicts = new ArrayList<>();
+
+    boolean vspModelConflicted = false;
+    for (ConflictInfo elementConflict : conflicts.getElementConflicts()) {
+      if (elementConflict.getType() == VspModel) {
+        elementConflicts.add(
+            new ConflictInfo(elementConflict.getId(), NetworkPackage, NetworkPackage.name()));
+        vspModelConflicted = true;
+        continue;
+      }
+      if (!FILTERED_OUT_TYPES.contains(elementConflict.getType())) {
+        elementConflicts.add(elementConflict);
+      }
+    }
+
+    if (!vspModelConflicted && vspMergeDao.isVspModelConflicted(itemId, version)) {
+      elementConflicts
+          .add(new ConflictInfo(VSP_MODEL_CONFLICT_ID, NetworkPackage, NetworkPackage.name()));
+    }
+
+    conflicts.setElementConflicts(elementConflicts);
+  }
+
+  @Override
+  public Optional<Conflict> getConflict(String itemId, Version version, String conflictId) {
+    return VSP_MODEL_CONFLICT_ID.equals(conflictId)
+        ? Optional.of(buildVspModelConflict(conflictId))
+        : Optional.empty();
+  }
+
+  @Override
+  public void postGetConflict(String itemId, Version version, Conflict conflict) {
+    if (conflict.getType() == VspModel) {
+      Conflict vspModelConflict = buildVspModelConflict(null);
+      conflict.setType(vspModelConflict.getType());
+      conflict.setName(vspModelConflict.getName());
+      conflict.setYours(vspModelConflict.getYours());
+      conflict.setTheirs(vspModelConflict.getTheirs());
+    }
+  }
+
+  @Override
+  public void preResolveConflict(String itemId, Version version, String conflictId,
+                                 ConflictResolution resolution) {
+    if (VSP_MODEL_CONFLICT_ID.equals(conflictId)) {
+      return;
+    }
+    resolveDependantConflicts(itemId, version, conflictId, resolution);
+  }
+
+  @Override
+  public boolean resolveConflict(String itemId, Version version, String conflictId,
+                                 ConflictResolution resolution) {
+    if (VSP_MODEL_CONFLICT_ID.equals(conflictId)) {
+      vspMergeDao.updateVspModelConflictResolution(itemId, version,
+          com.amdocs.zusammen.datatypes.item.Resolution.valueOf(resolution.getResolution().name()));
+      return true;
+    }
+    Conflict conflict = conflictsDao.getConflict(itemId, version, conflictId);
+    if (conflict == null) {
+      throw getConflictNotExistException(itemId, version, conflictId);
+    }
+    if (conflict.getType() == VspModel) {
+      vspMergeDao.updateVspModelConflictResolution(itemId, version,
+          com.amdocs.zusammen.datatypes.item.Resolution.valueOf(resolution.getResolution().name()));
+
+      conflictsDao.resolveConflict(itemId, version, conflictId, new ConflictResolution(
+          conflict.getTheirs() == null ? Resolution.YOURS : Resolution.THEIRS));
+      return true;
+    }
+    return false;
+  }
+
+  private void resolveDependantConflicts(String itemId, Version version, String conflictId,
+                                         ConflictResolution resolution) {
+    ItemVersionConflict conflicts = conflictsDao.getConflict(itemId, version);
+
+    Set<ElementType> conflictDependantTypes =
+        ELEMENT_TYPE_TO_CONFLICT_DEPENDANT_TYPES
+            .get(findConflictById(conflicts, conflictId).getType());
+
+    if (conflictDependantTypes == null) {
+      return;
+    }
+
+    findConflictsByTypes(conflicts, conflictDependantTypes)
+        .forEach(dependantConflict ->
+            conflictsDao.resolveConflict(itemId, version, dependantConflict.getId(), resolution));
+  }
+
+  private ConflictInfo findConflictById(ItemVersionConflict versionConflicts,
+                                        String conflictId) {
+    return versionConflicts.getElementConflicts().stream()
+        .filter(elementConflict -> conflictId.equals(elementConflict.getId()))
+        .findFirst()
+        .orElseThrow(() -> new IllegalStateException(
+            String.format("Conflict Id %s does not exist on conflicts list", conflictId)));
+  }
+
+  private Collection<ConflictInfo> findConflictsByTypes(ItemVersionConflict versionConflicts,
+                                                        Set<ElementType> elementTypes) {
+    return versionConflicts.getElementConflicts().stream()
+        .filter(elementConflict -> elementTypes.contains(elementConflict.getType()))
+        .collect(Collectors.toList());
+  }
+
+  private Conflict buildVspModelConflict(String conflictId) {
+    Conflict conflict = new Conflict(conflictId, NetworkPackage, NetworkPackage.name());
+
+    Map<String, String> yours = new HashMap<>();
+    yours.put("File", "Local (Me)");
+    conflict.setYours(yours);
+
+    Map<String, String> theirs = new HashMap<>();
+    theirs.put("File", "Last Committed");
+    conflict.setTheirs(theirs);
+    return conflict;
+  }
+
+  private CoreException getConflictNotExistException(String itemId, Version version,
+                                                     String conflictId) {
+    return new CoreException(new ErrorCode.ErrorCodeBuilder()
+        .withCategory(ErrorCategory.APPLICATION)
+        .withId(ELEMENT_CONFLICT_NOT_EXIST_ERR_ID)
+        .withMessage(
+            String.format(ELEMENT_CONFLICT_NOT_EXISTS_MSG, itemId, version.getId(), conflictId))
+        .build());
+  }
+}
diff --git a/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/resources/factoryConfiguration.json b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/resources/factoryConfiguration.json
new file mode 100644
index 0000000000..ec9f3703d1
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/openecomp-conflict-core/src/main/resources/factoryConfiguration.json
@@ -0,0 +1,4 @@
+{
+  "org.openecomp.conflicts.ItemMergeHandlerFactory": "org.openecomp.conflicts.ItemMergeHandlerFactoryImpl",
+  "org.openecomp.conflicts.dao.ConflictsDaoFactory": "org.openecomp.conflicts.dao.impl.zusammen.ConflictsDaoFactoryImpl"
+}
\ No newline at end of file
diff --git a/openecomp-be/lib/openecomp-conflict-lib/pom.xml b/openecomp-be/lib/openecomp-conflict-lib/pom.xml
new file mode 100644
index 0000000000..de6bcd6fef
--- /dev/null
+++ b/openecomp-be/lib/openecomp-conflict-lib/pom.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.openecomp.sdc</groupId>
+        <artifactId>openecomp-sdc-lib</artifactId>
+        <version>1.2.0-SNAPSHOT</version>
+        <relativePath>..</relativePath>
+    </parent>
+
+    <artifactId>openecomp-conflict-lib</artifactId>
+    <packaging>pom</packaging>
+    <modules>
+        <module>openecomp-conflict-api</module>
+        <module>openecomp-conflict-core</module>
+    </modules>
+</project>
\ No newline at end of file