Add versioning, session and zusammen libs

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

25 files changed, 1210 insertions, 0 deletions

diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java
new file mode 100644
index 0000000..a47ce00
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/ItemDao.java
@@ -0,0 +1,17 @@
+package org.onap.sdc.common.versioning.persistence;
+
+import java.util.Collection;
+import org.onap.sdc.common.versioning.persistence.types.InternalItem;
+
+public interface ItemDao {
+
+    Collection<InternalItem> list();
+
+    InternalItem get(String itemId);
+
+    InternalItem create(InternalItem item);
+
+    void update(InternalItem item);
+
+    void delete(String itemId);
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java
new file mode 100644
index 0000000..17354e8
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/VersionDao.java
@@ -0,0 +1,31 @@
+package org.onap.sdc.common.versioning.persistence;
+
+import java.util.List;
+import java.util.Optional;
+import org.onap.sdc.common.versioning.persistence.types.InternalVersion;
+import org.onap.sdc.common.versioning.services.types.Revision;
+
+public interface VersionDao {
+
+    List<InternalVersion> list(String itemId);
+
+    InternalVersion create(String itemId, InternalVersion version);
+
+    void update(String itemId, InternalVersion version);
+
+    Optional<InternalVersion> get(String itemId, String versionId);
+
+    void delete(String itemId, String versionId);
+
+    void publish(String itemId, String versionId, String message);
+
+    void sync(String itemId, String versionId);
+
+    void forceSync(String itemId, String versionId);
+
+    void clean(String itemId, String versionId);
+
+    void revert(String itemId, String versionId, String revisionId);
+
+    List<Revision> listRevisions(String itemId, String versionId);
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java
new file mode 100644
index 0000000..3d6610b
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalItem.java
@@ -0,0 +1,77 @@
+/*
+ *
+ *  Copyright © 2017-2018 European Support Limited
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.onap.sdc.common.versioning.persistence.types;
+
+import java.util.Date;
+import java.util.EnumMap;
+import java.util.Map;
+import lombok.Getter;
+import lombok.Setter;
+import org.onap.sdc.common.versioning.services.types.Item;
+import org.onap.sdc.common.versioning.services.types.ItemStatus;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+
+
+@Setter
+@Getter
+public class InternalItem extends Item {
+
+    private Map<VersionStatus, Integer> versionStatusCounters = new EnumMap<>(VersionStatus.class);
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public void setCreationTime(Date creationTime) {
+        this.creationTime = creationTime;
+    }
+
+    public void setModificationTime(Date modificationTime) {
+        this.modificationTime = modificationTime;
+    }
+
+    public void setStatus(ItemStatus status) {
+        this.status = status;
+    }
+
+    public void addVersionStatus(VersionStatus versionStatus) {
+        Integer counter = versionStatusCounters.get(versionStatus);
+        versionStatusCounters.put(versionStatus, counter == null ? 1 : counter + 1);
+    }
+
+    public void removeVersionStatus(VersionStatus versionStatus) {
+        Integer counter = versionStatusCounters.get(versionStatus);
+        if (counter == null) {
+            return;
+        }
+        if (counter == 1) {
+            versionStatusCounters.remove(versionStatus);
+        } else {
+            versionStatusCounters.put(versionStatus, counter - 1);
+        }
+    }
+
+    public void populateExternalFields(Item item) {
+        setType(item.getType());
+        setName(item.getName());
+        setOwner(item.getOwner());
+        setDescription(item.getDescription());
+        item.getProperties().forEach(this::addProperty);
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java
new file mode 100644
index 0000000..d48400b
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/types/InternalVersion.java
@@ -0,0 +1,42 @@
+package org.onap.sdc.common.versioning.persistence.types;
+
+import java.util.Date;
+import org.onap.sdc.common.versioning.services.types.Version;
+import org.onap.sdc.common.versioning.services.types.VersionState;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+
+public class InternalVersion extends Version {
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public void setBaseId(String baseId) {
+        this.baseId = baseId;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setStatus(VersionStatus status) {
+        this.status = status;
+    }
+
+    public void setState(VersionState state) {
+        this.state = state;
+    }
+
+    public void setCreationTime(Date creationTime) {
+        this.creationTime = creationTime;
+    }
+
+    public void setModificationTime(Date modificationTime) {
+        this.modificationTime = modificationTime;
+    }
+
+    public void populateExternalFields(Version version) {
+        setDescription(version.getDescription());
+        version.getProperties().forEach(this::addProperty);
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java
new file mode 100644
index 0000000..8530697
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDao.java
@@ -0,0 +1,126 @@
+package org.onap.sdc.common.versioning.persistence.zusammen;
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.item.Info;
+import com.amdocs.zusammen.datatypes.item.Item;
+import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.onap.sdc.common.versioning.persistence.ItemDao;
+import org.onap.sdc.common.versioning.persistence.types.InternalItem;
+import org.onap.sdc.common.versioning.services.types.ItemStatus;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+import org.onap.sdc.common.zusammen.services.ZusammenAdaptor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class ItemZusammenDao implements ItemDao {
+
+    private final ZusammenSessionContextCreator contextCreator;
+    private final ZusammenAdaptor zusammenAdaptor;
+
+    @Autowired
+    public ItemZusammenDao(ZusammenSessionContextCreator contextCreator, ZusammenAdaptor zusammenAdaptor) {
+        this.contextCreator = contextCreator;
+        this.zusammenAdaptor = zusammenAdaptor;
+    }
+
+    @Override
+    public Collection<InternalItem> list() {
+        return zusammenAdaptor.listItems(contextCreator.create()).stream().map(this::mapFromZusammenItem)
+                       .collect(Collectors.toList());
+    }
+
+    @Override
+    public InternalItem get(String itemId) {
+        return mapFromZusammenItem(zusammenAdaptor.getItem(contextCreator.create(), new Id(itemId)));
+    }
+
+    @Override
+    public InternalItem create(InternalItem item) {
+        Id itemId = zusammenAdaptor.createItem(contextCreator.create(), mapToZusammenItemInfo(item));
+        item.setId(itemId.getValue());
+        return item;
+    }
+
+    @Override
+    public void delete(String itemId) {
+        zusammenAdaptor.deleteItem(contextCreator.create(), new Id(itemId));
+    }
+
+    @Override
+    public void update(InternalItem item) {
+        zusammenAdaptor.updateItem(contextCreator.create(), new Id(item.getId()), mapToZusammenItemInfo(item));
+    }
+
+    private InternalItem mapFromZusammenItem(Item zusammenItem) {
+        if (zusammenItem == null) {
+            return null;
+        }
+        InternalItem item = new InternalItem();
+        item.setId(zusammenItem.getId().getValue());
+        item.setName(zusammenItem.getInfo().getName());
+        item.setDescription(zusammenItem.getInfo().getDescription());
+
+        zusammenItem.getInfo().getProperties().forEach((key, value) -> addPropertyToItem(key, value, item));
+
+        item.setCreationTime(zusammenItem.getCreationTime());
+        item.setModificationTime(zusammenItem.getModificationTime());
+
+        if (item.getStatus() == null) {
+            item.setStatus(ItemStatus.ACTIVE);
+            update(item);
+        }
+
+        return item;
+    }
+
+    private void addPropertyToItem(String propertyKey, Object propertyValue, InternalItem item) {
+        switch (propertyKey) {
+            case InfoPropertyName.ITEM_TYPE:
+                item.setType((String) propertyValue);
+                break;
+            case InfoPropertyName.ITEM_OWNER:
+                item.setOwner((String) propertyValue);
+                break;
+            case InfoPropertyName.ITEM_STATUS:
+                item.setStatus(ItemStatus.valueOf((String) propertyValue));
+                break;
+            case InfoPropertyName.ITEM_VERSIONS_STATUSES:
+                for (Map.Entry<String, Number> statusCounter : ((Map<String, Number>) propertyValue).entrySet()) {
+                    item.getVersionStatusCounters()
+                            .put(VersionStatus.valueOf(statusCounter.getKey()), statusCounter.getValue().intValue());
+                }
+                break;
+            default:
+                item.addProperty(propertyKey, propertyValue);
+        }
+    }
+
+    private Info mapToZusammenItemInfo(InternalItem item) {
+        Info info = new Info();
+        info.setName(item.getName());
+        info.setDescription(item.getDescription());
+        info.addProperty(InfoPropertyName.ITEM_TYPE, item.getType());
+        info.addProperty(InfoPropertyName.ITEM_OWNER, item.getOwner());
+        if (item.getStatus() != null) {
+            info.addProperty(InfoPropertyName.ITEM_STATUS, item.getStatus());
+        }
+        info.addProperty(InfoPropertyName.ITEM_VERSIONS_STATUSES, item.getVersionStatusCounters());
+        item.getProperties().forEach(info::addProperty);
+        return info;
+    }
+
+    private static final class InfoPropertyName {
+
+        private static final String ITEM_TYPE = "item_type";
+        private static final String ITEM_VERSIONS_STATUSES = "item_versions_statuses";
+        private static final String ITEM_OWNER = "Owner";
+        private static final String ITEM_STATUS = "status";
+
+        private InfoPropertyName() {
+            throw new IllegalStateException("Constants class");
+        }
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java
new file mode 100644
index 0000000..cb062c7
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDao.java
@@ -0,0 +1,202 @@
+package org.onap.sdc.common.versioning.persistence.zusammen;
+
+
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Info;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import com.amdocs.zusammen.datatypes.item.ItemVersionData;
+import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
+import com.amdocs.zusammen.datatypes.item.SynchronizationStatus;
+import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import org.onap.sdc.common.versioning.persistence.VersionDao;
+import org.onap.sdc.common.versioning.persistence.types.InternalVersion;
+import org.onap.sdc.common.versioning.services.exceptions.VersioningException;
+import org.onap.sdc.common.versioning.services.types.Revision;
+import org.onap.sdc.common.versioning.services.types.SynchronizationState;
+import org.onap.sdc.common.versioning.services.types.VersionState;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+import org.onap.sdc.common.zusammen.services.ZusammenAdaptor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class VersionZusammenDao implements VersionDao {
+
+    private static final String STATUS_PROPERTY = "status";
+
+    private final ZusammenSessionContextCreator contextCreator;
+    private final ZusammenAdaptor zusammenAdaptor;
+
+    @Autowired
+    public VersionZusammenDao(ZusammenSessionContextCreator contextCreator, ZusammenAdaptor zusammenAdaptor) {
+        this.contextCreator = contextCreator;
+        this.zusammenAdaptor = zusammenAdaptor;
+    }
+
+    @Override
+    public List<InternalVersion> list(String itemId) {
+        return zusammenAdaptor.listPublicVersions(contextCreator.create(), new Id(itemId)).stream()
+                       .map(VersionZusammenDao::convertFromZusammen).collect(Collectors.toList());
+    }
+
+    @Override
+    public InternalVersion create(String itemId, InternalVersion version) {
+        Id versionId = zusammenAdaptor.createVersion(contextCreator.create(), new Id(itemId),
+                version.getBaseId() == null ? null : new Id(version.getBaseId()), mapToZusammenVersion(version));
+
+        version.setId(versionId.getValue());
+        return version;
+    }
+
+    @Override
+    public void update(String itemId, InternalVersion version) {
+        zusammenAdaptor.updateVersion(contextCreator.create(), new Id(itemId), new Id(version.getId()),
+                mapToZusammenVersion(version));
+    }
+
+    @Override
+    public Optional<InternalVersion> get(String itemId, String versionId) {
+        SessionContext context = contextCreator.create();
+        Id itemIdObj = new Id(itemId);
+        Id versionIdObj = new Id(versionId);
+        ItemVersion itemVersion = zusammenAdaptor.getVersion(context, itemIdObj, versionIdObj);
+
+        if (itemVersion == null) {
+            return Optional.empty();
+        }
+
+        VersionState versionState = convertState(zusammenAdaptor.getVersionStatus(context, itemIdObj, versionIdObj));
+        updateVersionStatus(context, itemIdObj, versionIdObj, versionState, itemVersion);
+
+        InternalVersion result = convertFromZusammen(itemVersion);
+        result.setState(versionState);
+        return Optional.of(result);
+    }
+
+    @Override
+    public void delete(String itemId, String versionId) {
+        throw new UnsupportedOperationException("Delete version operation is not yet supported.");
+    }
+
+    @Override
+    public void publish(String itemId, String versionId, String message) {
+        zusammenAdaptor.publishVersion(contextCreator.create(), new Id(itemId), new Id(versionId), message);
+    }
+
+    @Override
+    public void sync(String itemId, String versionId) {
+        zusammenAdaptor.syncVersion(contextCreator.create(), new Id(itemId), new Id(versionId));
+    }
+
+    @Override
+    public void forceSync(String itemId, String versionId) {
+        zusammenAdaptor.forceSyncVersion(contextCreator.create(), new Id(itemId), new Id(versionId));
+    }
+
+    @Override
+    public void clean(String itemId, String versionId) {
+        zusammenAdaptor.cleanVersion(contextCreator.create(), new Id(itemId), new Id(versionId));
+    }
+
+    @Override
+    public void revert(String itemId, String versionId, String revisionId) {
+        zusammenAdaptor.revert(contextCreator.create(), new Id(itemId), new Id(versionId), new Id(revisionId));
+    }
+
+    @Override
+    public List<Revision> listRevisions(String itemId, String versionId) {
+        ItemVersionRevisions itemVersionRevisions =
+                zusammenAdaptor.listRevisions(contextCreator.create(), new Id(itemId), new Id(versionId));
+
+        return itemVersionRevisions == null || itemVersionRevisions.getItemVersionRevisions() == null
+                       || itemVersionRevisions.getItemVersionRevisions().isEmpty() ? new ArrayList<>() :
+                       itemVersionRevisions.getItemVersionRevisions().stream().map(this::convertRevision)
+                               .sorted(this::compareRevisionsTime).collect(Collectors.toList());
+    }
+
+    private void updateVersionStatus(SessionContext context, Id itemId, Id versionId, VersionState versionState,
+            ItemVersion itemVersion) {
+        if (versionState.getSynchronizationState() != SynchronizationState.UpToDate) {
+            String versionStatus = zusammenAdaptor.getPublicVersion(context, itemId, versionId).getData().getInfo()
+                                           .getProperty(STATUS_PROPERTY);
+            itemVersion.getData().getInfo().addProperty(STATUS_PROPERTY, versionStatus);
+        }
+    }
+
+    private ItemVersionData mapToZusammenVersion(InternalVersion version) {
+        Info info = new Info();
+        info.addProperty(STATUS_PROPERTY, version.getStatus().name());
+        info.setName(version.getName());
+        info.setDescription(version.getDescription());
+        version.getProperties().forEach(info::addProperty);
+        ItemVersionData itemVersionData = new ItemVersionData();
+        itemVersionData.setInfo(info);
+        return itemVersionData;
+    }
+
+    private VersionState convertState(ItemVersionStatus versionStatus) {
+        VersionState state = new VersionState();
+        state.setSynchronizationState(getSyncState(versionStatus.getSynchronizationStatus()));
+        state.setDirty(versionStatus.isDirty());
+        return state;
+    }
+
+    private SynchronizationState getSyncState(SynchronizationStatus synchronizationStatus) {
+        switch (synchronizationStatus) {
+            case UP_TO_DATE:
+                return SynchronizationState.UpToDate;
+            case OUT_OF_SYNC:
+                return SynchronizationState.OutOfSync;
+            case MERGING:
+                return SynchronizationState.Merging;
+            default:
+                throw new VersioningException("Version state is unknown");
+        }
+    }
+
+    private Revision convertRevision(com.amdocs.zusammen.datatypes.itemversion.Revision zusammenRevision) {
+        Revision revision = new Revision();
+        revision.setId(zusammenRevision.getRevisionId().getValue());
+        revision.setTime(zusammenRevision.getTime());
+        revision.setUser(zusammenRevision.getUser());
+        revision.setMessage(zusammenRevision.getMessage());
+        return revision;
+    }
+
+    private int compareRevisionsTime(Revision revision1, Revision revision2) {
+        return revision1.getTime().before(revision2.getTime()) ? 1 : -1;
+    }
+
+    private static InternalVersion convertFromZusammen(ItemVersion itemVersion) {
+        if (itemVersion == null) {
+            return null;
+        }
+        InternalVersion version = new InternalVersion();
+        version.setId(itemVersion.getId().getValue());
+        if (itemVersion.getBaseId() != null) {
+            version.setBaseId(itemVersion.getBaseId().getValue());
+        }
+        version.setName(itemVersion.getData().getInfo().getName());
+        version.setDescription(itemVersion.getData().getInfo().getDescription());
+        version.setCreationTime(itemVersion.getCreationTime());
+        version.setModificationTime(itemVersion.getModificationTime());
+
+        itemVersion.getData().getInfo().getProperties()
+                .forEach((key, value) -> addPropertyToVersion(key, value, version));
+
+        return version;
+    }
+
+    private static void addPropertyToVersion(String propertyKey, Object propertyValue, InternalVersion version) {
+        if (STATUS_PROPERTY.equals(propertyKey)) {
+            version.setStatus(VersionStatus.valueOf((String) propertyValue));
+        } else {
+            version.addProperty(propertyKey, propertyValue);
+        }
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java
new file mode 100644
index 0000000..f8a677a
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/persistence/zusammen/ZusammenSessionContextCreator.java
@@ -0,0 +1,28 @@
+package org.onap.sdc.common.versioning.persistence.zusammen;
+
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.UserInfo;
+import org.onap.sdc.common.session.SessionContextProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class ZusammenSessionContextCreator {
+
+    private final SessionContextProvider sessionContextProvider;
+
+    @Autowired
+    public ZusammenSessionContextCreator(SessionContextProvider sessionContextProvider) {
+        this.sessionContextProvider = sessionContextProvider;
+    }
+
+
+    public SessionContext create() {
+        org.onap.sdc.common.session.SessionContext sdcSessionContext = sessionContextProvider.get();
+
+        SessionContext sessionContext = new SessionContext();
+        sessionContext.setUser(new UserInfo(sdcSessionContext.getUserId()));
+        sessionContext.setTenant(sdcSessionContext.getTenant());
+        return sessionContext;
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java
new file mode 100644
index 0000000..de91f2e
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/ItemManager.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.common.versioning.services;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+import org.onap.sdc.common.versioning.services.types.Item;
+import org.onap.sdc.common.versioning.services.types.ItemStatus;
+
+public interface ItemManager {
+
+    Collection<Item> list(Predicate<Item> predicate);
+
+    Item get(String itemId);
+
+    Item create(Item item);
+
+    Item update(String itemId, Item item);
+
+    void delete(String itemId);
+
+    void updateStatus(String itemId, ItemStatus status);
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java
new file mode 100644
index 0000000..f522077
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/VersioningManager.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.common.versioning.services;
+
+import java.util.List;
+import org.onap.sdc.common.versioning.services.types.Revision;
+import org.onap.sdc.common.versioning.services.types.Version;
+import org.onap.sdc.common.versioning.services.types.VersionCreationMethod;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+
+public interface VersioningManager {
+
+    List<Version> list(String itemId); // TODO: 5/24/2017 filter (by status for example)
+
+    Version get(String itemId, String versionId);
+
+    Version create(String itemId, String baseVersionId, Version version, VersionCreationMethod creationMethod);
+
+    Version update(String itemId, String versionId, Version version);
+
+    void updateStatus(String itemId, String versionId, VersionStatus status, String message);
+
+    void publish(String itemId, String versionId, String message);
+
+    void sync(String itemId, String versionId);
+
+    void forceSync(String itemId, String versionId);
+
+    void revert(String itemId, String versionId, String revisionId);
+
+    List<Revision> listRevisions(String itemId, String versionId);
+
+    void clean(String itemId, String versionId);
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java
new file mode 100644
index 0000000..88405e5
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/ItemConvertor.java
@@ -0,0 +1,17 @@
+package org.onap.sdc.common.versioning.services.convertors;
+
+import org.onap.sdc.common.versioning.services.types.Item;
+
+public interface ItemConvertor<T> {
+
+    String getItemType();
+
+    //Item toItem(T model);
+
+    void toItem(T source, Item target);
+
+   // void fromItem(Item source, T target);
+
+    T fromItem(Item item);
+
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java
new file mode 100644
index 0000000..beab1d9
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/convertors/VersionConvertor.java
@@ -0,0 +1,16 @@
+package org.onap.sdc.common.versioning.services.convertors;
+
+import org.onap.sdc.common.versioning.services.types.Version;
+
+public interface VersionConvertor<T> {
+
+    String getItemType();
+
+    //Version toVersion(T model);
+
+    void toVersion(T source, Version target);
+
+    //void fromVersion(Version source, T target);
+
+    T fromVersion(Version version);
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java
new file mode 100644
index 0000000..6440ccc
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/exceptions/VersioningException.java
@@ -0,0 +1,8 @@
+package org.onap.sdc.common.versioning.services.exceptions;
+
+public class VersioningException extends RuntimeException {
+
+    public VersioningException(String message) {
+        super(message);
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java
new file mode 100644
index 0000000..47acabc
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/ItemManagerImpl.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.common.versioning.services.impl;
+
+import java.util.Collection;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import org.onap.sdc.common.versioning.persistence.ItemDao;
+import org.onap.sdc.common.versioning.persistence.types.InternalItem;
+import org.onap.sdc.common.versioning.services.ItemManager;
+import org.onap.sdc.common.versioning.services.exceptions.VersioningException;
+import org.onap.sdc.common.versioning.services.types.Item;
+import org.onap.sdc.common.versioning.services.types.ItemStatus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class ItemManagerImpl implements ItemManager {
+
+    private final ItemDao itemDao;
+
+    @Autowired
+    public ItemManagerImpl(ItemDao itemDao) {
+        this.itemDao = itemDao;
+
+    }
+
+    @Override
+    public Collection<Item> list(Predicate<Item> predicate) {
+        return itemDao.list().stream().filter(predicate).collect(Collectors.toList());
+    }
+
+    @Override
+    public Item get(String itemId) {
+        return itemDao.get(itemId);
+    }
+
+    @Override
+    public Item create(Item item) {
+        InternalItem internalItem = new InternalItem();
+        internalItem.populateExternalFields(item);
+        return itemDao.create(internalItem);
+    }
+
+    @Override
+    public Item update(String itemId, Item item) {
+        InternalItem internalItem = getItem(itemId);
+        internalItem.populateExternalFields(item);
+        itemDao.update(internalItem);
+        return internalItem;
+    }
+
+    @Override
+    public void delete(String itemId) {
+        itemDao.delete(itemId);
+    }
+
+    @Override
+    public void updateStatus(String itemId, ItemStatus status) {
+        InternalItem item = getItem(itemId);
+        if (item.getStatus() == status) {
+            throw new VersioningException(
+                    String.format("Update status of item %s failed, it is already in status %s", item.getId(), status));
+        }
+
+        item.setStatus(status);
+        itemDao.update(item);
+    }
+
+    private InternalItem getItem(String itemId) {
+        InternalItem item = itemDao.get(itemId);
+        if (item == null) {
+            throw new VersioningException(String.format("Item with Id %s does not exist", itemId));
+        }
+        return item;
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java
new file mode 100644
index 0000000..a98fa58
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImpl.java
@@ -0,0 +1,46 @@
+package org.onap.sdc.common.versioning.services.impl;
+
+import java.util.HashSet;
+import java.util.Set;
+import org.onap.sdc.common.versioning.services.types.Version;
+import org.onap.sdc.common.versioning.services.types.VersionCreationMethod;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+import org.springframework.stereotype.Service;
+
+@Service
+public class MajorVersionCalculatorImpl implements VersionCalculator {
+
+    private static final String INITIAL_VERSION = "1.0";
+    private static final String VERSION_STRING_VIOLATION_MSG =
+            "Version string must be in the format of: {integer}.{integer}";
+
+    @Override
+    public String calculate(String baseVersion, VersionCreationMethod creationMethod) {
+
+        if (baseVersion == null) {
+            return INITIAL_VERSION;
+        }
+
+        String[] versionLevels = baseVersion.split("\\.");
+        if (versionLevels.length != 2) {
+            throw new IllegalArgumentException(VERSION_STRING_VIOLATION_MSG);
+        }
+
+        int index = Integer.parseInt(versionLevels[0]);
+        index++;
+
+        return index + ".0";
+    }
+
+    @Override
+    public void injectAdditionalInfo(Version version, Set<String> existingVersions) {
+        Set<VersionCreationMethod> optionalCreationMethods = new HashSet<>();
+        if (version.getStatus().equals(VersionStatus.Certified)) {
+            String nextVersion = calculate(version.getName(), VersionCreationMethod.major);
+            if (!existingVersions.contains(nextVersion)) {
+                optionalCreationMethods.add(VersionCreationMethod.major);
+            }
+        }
+        version.addProperty("OptionalCreationMethods", optionalCreationMethods);
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java
new file mode 100644
index 0000000..203dfbb
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersionCalculator.java
@@ -0,0 +1,12 @@
+package org.onap.sdc.common.versioning.services.impl;
+
+import java.util.Set;
+import org.onap.sdc.common.versioning.services.types.Version;
+import org.onap.sdc.common.versioning.services.types.VersionCreationMethod;
+
+public interface VersionCalculator {
+
+    String calculate(String baseVersion, VersionCreationMethod creationMethod);
+
+    void injectAdditionalInfo(Version version, Set<String> existingVersions);
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java
new file mode 100644
index 0000000..601f517
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.common.versioning.services.impl;
+
+
+import static org.onap.sdc.common.versioning.services.types.VersionStatus.Certified;
+import static org.onap.sdc.common.versioning.services.types.VersionStatus.Draft;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.onap.sdc.common.versioning.persistence.ItemDao;
+import org.onap.sdc.common.versioning.persistence.VersionDao;
+import org.onap.sdc.common.versioning.persistence.types.InternalItem;
+import org.onap.sdc.common.versioning.persistence.types.InternalVersion;
+import org.onap.sdc.common.versioning.services.VersioningManager;
+import org.onap.sdc.common.versioning.services.exceptions.VersioningException;
+import org.onap.sdc.common.versioning.services.types.Revision;
+import org.onap.sdc.common.versioning.services.types.SynchronizationState;
+import org.onap.sdc.common.versioning.services.types.Version;
+import org.onap.sdc.common.versioning.services.types.VersionCreationMethod;
+import org.onap.sdc.common.versioning.services.types.VersionStatus;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class VersioningManagerImpl implements VersioningManager {
+
+    //private static final Logger LOGGER = LoggerFactory.getLogger(VersioningManagerImpl.class);
+
+    private final ItemDao itemDao;
+    private final VersionDao versionDao;
+    private final VersionCalculator versionCalculator;
+
+    @Autowired
+    public VersioningManagerImpl(VersionDao versionDao, VersionCalculator versionCalculator, ItemDao itemDao) {
+        this.itemDao = itemDao;
+        this.versionDao = versionDao;
+        this.versionCalculator = versionCalculator;
+    }
+
+
+    @Override
+    public List<Version> list(String itemId) {
+        List<InternalVersion> versions = versionDao.list(itemId);
+        Set<String> versionsNames = versions.stream().map(Version::getName).collect(Collectors.toSet());
+        versions.forEach(version -> versionCalculator.injectAdditionalInfo(version, versionsNames));
+        return versions.stream().map(version -> (Version) version).collect(Collectors.toList());
+    }
+
+    @Override
+    public Version get(String itemId, String versionId) {
+        return getVersion(itemId, versionId);
+    }
+
+    @Override
+    public Version create(String itemId, String baseVersionId, Version version, VersionCreationMethod creationMethod) {
+        InternalVersion internalVersion = new InternalVersion();
+        internalVersion.setBaseId(baseVersionId);
+        internalVersion.populateExternalFields(version);
+
+        String baseVersionName = null;
+        if (baseVersionId != null) {
+            Version baseVersion = getVersion(itemId, baseVersionId);
+            validateBaseVersion(itemId, baseVersion);
+            baseVersionName = baseVersion.getName();
+        }
+        String versionName = versionCalculator.calculate(baseVersionName, creationMethod);
+        validateVersionName(itemId, versionName);
+        internalVersion.setName(versionName);
+
+        InternalVersion createdVersion = versionDao.create(itemId, internalVersion);
+
+        updateStatusOnItem(itemId, Draft, null);
+
+        publish(itemId, createdVersion.getId(), String.format("Create version: %s", versionName));
+        return createdVersion;
+    }
+
+    @Override
+    public Version update(String itemId, String versionId, Version version) {
+        InternalVersion internalVersion = getVersion(itemId, versionId);
+        internalVersion.populateExternalFields(version);
+        versionDao.update(itemId, internalVersion);
+        return internalVersion;
+    }
+
+    @Override
+    public void updateStatus(String itemId, String versionId, VersionStatus status, String message) {
+        InternalVersion version = getVersion(itemId, versionId);
+
+        VersionStatus prevStatus = version.getStatus();
+        if (prevStatus == status) {
+            throw new VersioningException(
+                    String.format("Item %s: update version status failed, version %s is already in status %s", itemId,
+                            version.getId(), status));
+        }
+
+        version.setStatus(status);
+        versionDao.update(itemId, version);
+
+        publish(itemId, versionId, message);
+
+        updateStatusOnItem(itemId, status, prevStatus);
+    }
+
+    @Override
+    public void publish(String itemId, String versionId, String message) {
+        versionDao.publish(itemId, versionId, message);
+    }
+
+    @Override
+    public void sync(String itemId, String versionId) {
+        versionDao.sync(itemId, versionId);
+    }
+
+    @Override
+    public void forceSync(String itemId, String versionId) {
+        versionDao.forceSync(itemId, versionId);
+    }
+
+    @Override
+    public void revert(String itemId, String versionId, String revisionId) {
+        versionDao.revert(itemId, versionId, revisionId);
+    }
+
+    @Override
+    public List<Revision> listRevisions(String itemId, String versionId) {
+        return versionDao.listRevisions(itemId, versionId);
+    }
+
+    @Override
+    public void clean(String itemId, String versionId) {
+        versionDao.clean(itemId, versionId);
+    }
+
+    private InternalVersion getVersion(String itemId, String versionId) {
+        return versionDao.get(itemId, versionId)
+                       .map(retrievedVersion -> getUpdateRetrievedVersion(itemId, retrievedVersion))
+                       .orElseGet(() -> getSyncedVersion(itemId, versionId));
+    }
+
+    private InternalVersion getUpdateRetrievedVersion(String itemId, InternalVersion version) {
+        if (version.getStatus() == Certified
+                    && version.getState().getSynchronizationState() == SynchronizationState.OutOfSync) {
+            forceSync(itemId, version.getId());
+            //LOGGER.info("Item Id {}, version Id {}: Force sync is done", itemId, version.getId());
+            version = versionDao.get(itemId, version.getId()).orElseThrow(() -> new IllegalStateException(
+                    "Get version after a successful force sync must return the version"));
+        }
+        return version;
+    }
+
+    private InternalVersion getSyncedVersion(String itemId, String versionId) {
+        sync(itemId, versionId);
+        //LOGGER.info("Item Id {}, version Id {}: First time sync is done", itemId, version.getId());
+        return versionDao.get(itemId, versionId).orElseThrow(
+                () -> new IllegalStateException("Get version after a successful sync must return the version"));
+    }
+
+    private void validateBaseVersion(String itemId, Version baseVersion) {
+        if (Certified != baseVersion.getStatus()) {
+            throw new VersioningException(
+                    String.format("Item %s: base version %s must be Certified", itemId, baseVersion.getId()));
+        }
+    }
+
+    private void validateVersionName(String itemId, String versionName) {
+        if (versionDao.list(itemId).stream().anyMatch(version -> versionName.equals(version.getName()))) {
+            throw new VersioningException(
+                    String.format("Item %s: create version failed, a version with the name %s already exist", itemId,
+                            versionName));
+        }
+    }
+
+    private void updateStatusOnItem(String itemId, VersionStatus addedVersionStatus,
+            VersionStatus removedVersionStatus) {
+        InternalItem item = itemDao.get(itemId);
+        if (item == null) {
+            throw new VersioningException(String.format("Item with Id %s does not exist", itemId));
+        }
+        item.addVersionStatus(addedVersionStatus);
+        if (removedVersionStatus != null) {
+            item.removeVersionStatus(removedVersionStatus);
+        }
+        itemDao.update(item);
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java
new file mode 100644
index 0000000..796fc1a
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Item.java
@@ -0,0 +1,55 @@
+/*
+ *
+ *  Copyright © 2017-2018 European Support Limited
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.onap.sdc.common.versioning.services.types;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+public class Item {
+
+    protected String id;
+    protected Date creationTime;
+    protected Date modificationTime;
+    protected ItemStatus status;
+    @Setter
+    private String type;
+    @Setter
+    private String name;
+    @Setter
+    private String owner;
+    @Setter
+    private String description;
+    private Map<String, Object> properties = new HashMap<>();
+
+    public boolean isNew() {
+        return id == null;
+    }
+
+    public void addProperty(String key, Object value) {
+        properties.put(key, value);
+    }
+
+    public <T> T getProperty(String key) {
+        return (T) properties.get(key);
+    }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java
new file mode 100644
index 0000000..57b5f23
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/ItemStatus.java
@@ -0,0 +1,5 @@
+package org.onap.sdc.common.versioning.services.types;
+
+public enum ItemStatus {
+    ACTIVE, ARCHIVED
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java
new file mode 100644
index 0000000..10cadb5
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Revision.java
@@ -0,0 +1,15 @@
+package org.onap.sdc.common.versioning.services.types;
+
+import java.util.Date;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class Revision {
+
+    private String id;
+    private String message;
+    private Date time;
+    private String user;
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java
new file mode 100644
index 0000000..dd2efcc
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/SynchronizationState.java
@@ -0,0 +1,17 @@
+package org.onap.sdc.common.versioning.services.types;
+
+public enum SynchronizationState {
+  UpToDate("Up to date"),
+  OutOfSync("Out of sync"),
+  Merging("Merging");
+
+  private final String displayName;
+
+  SynchronizationState(String displayName) {
+    this.displayName = displayName;
+  }
+
+  public String toString() {
+    return this.displayName;
+  }
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java
new file mode 100644
index 0000000..5cb0b69
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/Version.java
@@ -0,0 +1,56 @@
+/*-
+ * ============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.onap.sdc.common.versioning.services.types;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@NoArgsConstructor
+public class Version {
+
+    protected String id;
+    protected String baseId;
+    protected String name;
+    protected VersionStatus status = VersionStatus.Draft;
+    protected VersionState state;
+    protected Date creationTime;
+    protected Date modificationTime;
+    @Setter
+    private String description;
+    private Map<String, Object> properties = new HashMap<>();
+
+    public boolean isNew() {
+        return id == null;
+    }
+
+    public void addProperty(String key, Object value) {
+        properties.put(key, value);
+    }
+
+    public <T> T getProperty(String key) {
+        return (T) properties.get(key);
+    }
+}
\ No newline at end of file
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java
new file mode 100644
index 0000000..3e18c28
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionCreationMethod.java
@@ -0,0 +1,5 @@
+package org.onap.sdc.common.versioning.services.types;
+
+public enum VersionCreationMethod {
+    major, minor
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java
new file mode 100644
index 0000000..755c671
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionState.java
@@ -0,0 +1,11 @@
+package org.onap.sdc.common.versioning.services.types;
+
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class VersionState {
+  private SynchronizationState synchronizationState;
+  private boolean dirty;
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java
new file mode 100644
index 0000000..53c2e8f
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionStatus.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.common.versioning.services.types;
+
+public enum VersionStatus {
+    Draft, Certified, Deprecated, Deleted
+}
diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java
new file mode 100644
index 0000000..771959b
--- /dev/null
+++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/types/VersionType.java
@@ -0,0 +1,25 @@
+/*-
+ * ============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.onap.sdc.common.versioning.services.types;
+
+public enum VersionType {
+    Draft, Finalized
+}